Wing

https://github.com/winglang/wing
Admin
Wing is a cloud-oriented programming language that enables developers to build distributed systems...
Tokens:589,369
Snippets:4,518
Trust Score:8.3
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Initialize API Get Options

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/api.md

Example of initializing the ApiGetOptions structure.

```wing
bring cloud;

let ApiGetOptions = cloud.ApiGetOptions{ ... };
```

--------------------------------

### Define a Service with Initialized Start Time

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/sim/state.md

This example demonstrates how to create a simulated service that captures its initialization start time using `sim.State`. The `startTime` property is set using a token resolved during simulator initialization.

```wing
bring cloud;
bring sim;

class MyService {
  startTime: str;

  new() {
    let state = new sim.State();

    new cloud.Service(inflight () => {
      state.set("start", std.Datetime.utcNow().toIso());
    });

    this.startTime = state.token("start");
  }
}
```

--------------------------------

### Install and initialize Wing backend

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

Commands to install the Wing CLI and initialize a new backend project.

```sh
npm install -g winglang
wing --version # should be >= 0.60.1
```

```sh
mkdir ~/shared-counter/backend
cd ~/shared-counter/backend
```

```sh
wing new empty
```

```sh
wing it
```

--------------------------------

### Wing API Example

Source: https://github.com/winglang/wing/blob/main/docs/contributing/999-rfcs/2023-01-20-wingsdk-spec.md

Demonstrates how to create an API resource in Wing, define GET and POST routes, and handle requests with inflight functions. Includes example curl commands for testing.

```wing
// wing
let api = new cloud.Api();

api.get("/hello", inflight (req: cloud.ApiRequest): cloud.ApiResponse => {
  return cloud.ApiResponse {
    status: 200,
    body: "Hello, world!"
  };
});

api.post("/hello", inflight (req: cloud.ApiRequest): cloud.ApiResponse => {
  return cloud.ApiResponse {
    status: 200,
    body: "Hello, " + req.body + "!"
  };
});

// curl
$ curl https://api.example.com/hello
Hello, world!

$ curl -X POST -d "world" https://api.example.com/hello
Hello, world!
```

--------------------------------

### Full main.w Example

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

A complete example of `main.w` demonstrating the integration of Vite, cloud API, and a counter, including API routes and environment variable configuration.

```wing
bring vite;
bring cloud;

let api = new cloud.Api(cors: true);
let counter = new cloud.Counter();

api.get("/counter", inflight () => {
  return {
    body: "{counter.peek()}"
  };
});

api.post("/counter", inflight () => {
  let prev = counter.inc();
  return {
    body: "{prev + 1}"
  };
});

new vite.Vite(
  root: "../frontend",
  publicEnv: {
    TITLE: "Wing + Vite + React",
    API_URL: api.url
  }
);  
```

--------------------------------

### Initialize and start the Wing simulator

Source: https://github.com/winglang/wing/blob/main/docs/docs/02-concepts/05-simulator.md

Create a Simulator instance using a compiled .wsim file and manage its lifecycle with start and stop methods.

```typescript
import { testing } from '@winglang/sdk';

async function main() {
  const sim = new testing.Simulator({ simfile: "hello.wsim" });
  await sim.start();

  // (1)

  await sim.stop();
}

void main();
```

--------------------------------

### Install @wingconsole/server

Source: https://github.com/winglang/wing/blob/main/wing-console/console/server/readme.md

Install the @wingconsole/server package using npm.

```sh
npm i @wingconsole/server
```

--------------------------------

### Install Wing CLI

Source: https://github.com/winglang/wing/blob/main/docs/api/02-cli-user-manual.md

Install the Wing CLI globally using npm.

```bash
npm i -g winglang
```

--------------------------------

### Install react-use-websocket

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

Install the react-use-websocket library in your frontend project.

```sh
cd ~/shared-counter/frontend
npm i react-use-websocket
```

--------------------------------

### Install Wing Compiler

Source: https://github.com/winglang/wing/blob/main/packages/@winglang/compiler/README.md

Install the Wing Compiler Node.js package using npm.

```sh
npm install @winglang/compiler
```

--------------------------------

### Resource Path Example

Source: https://github.com/winglang/wing/blob/main/docs/contributing/999-rfcs/2022-08-22-resource-naming.md

Example of a full resource path for a cloud function in a Wing application.

```text
my-demo-app/Dev/default/ImageExtractor/default/ImageScraper/default/PageParser/default
```

--------------------------------

### Install Containers Library

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/workload.md

Install the necessary library for using the Workload resource. Requires Docker or OrbStack for local simulation.

```sh
npm i @winglibs/containers
```

--------------------------------

### Build the project

Source: https://github.com/winglang/wing/blob/main/packages/@winglang/wingc/CONTRIBUTING.md

Command to install dependencies for the project.

```sh
cargo something
```

--------------------------------

### Install and Compile with AWS CDK Platform

Source: https://github.com/winglang/wing/blob/main/packages/@winglang/platform-awscdk/README.md

Install the AWS CDK platform using npm and compile your Wing project. Ensure you replace `<wing_entrypoint_file>` with your actual entrypoint file.

```bash
# Install the platform
npm i @winglang/platform-awscdk

# Compile your project
wing compile --platform @winglang/platform-awscdk <wing_entrypoint_file>
```

--------------------------------

### Initialize a Wing React-Vite project

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

Use the quickstart template to automate the generation of the project structure.

```bash
$ mkdir my-react-vite
$ cd my-react-vite
$ wing new react-vite
```

--------------------------------

### Log Service Start Time in a Function

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/sim/state.md

This example shows how to reference the `startTime` of a `MyService` instance within a `cloud.Function`. The logging statement will only execute after the state `start` is set, creating an implicit dependency.

```wing
let s = new MyService();

new cloud.Function(inflight () => {
  log("service start time is {s}");
});
```

--------------------------------

### Create New Wing Project

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/04-private-api-gateway-aws.md

Initializes a new project using the private-api quickstart template.

```bash
$ mkdir my-api
$ cd my-api
$ wing new private-api
```

--------------------------------

### Wing Cloud Resource Example

Source: https://github.com/winglang/wing/blob/main/README.md

This example demonstrates defining cloud resources like queues, counters, and buckets in Wing. Preflight objects represent infrastructure, and their methods can configure inflight functions.

```wing
bring cloud;

let queue = new cloud.Queue();
let counter = new cloud.Counter();
let bucket = new cloud.Bucket();

queue.setConsumer(inflight (message) => {
  let i = counter.inc();
  bucket.put("file-{i}.txt", message);
});
```

--------------------------------

### Wing Cloud Bucket Get Options

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/bucket.md

Options for the Bucket.get() method, allowing specification of start and end bytes for partial reads.

```wing
bring cloud;

let BucketGetOptions = cloud.BucketGetOptions{ ... };
```

```wing
endByte: num;
```

```wing
startByte: num;
```

--------------------------------

### Wing Cloud Resource Example

Source: https://github.com/winglang/wing/blob/main/packages/winglang/README.md

This example demonstrates defining cloud resources like queues, counters, and buckets in Wing's preflight phase and configuring an inflight function to process messages.

```wing
bring cloud;

let queue = new cloud.Queue();
let counter = new cloud.Counter();
let bucket = new cloud.Bucket();

queue.setConsumer(inflight (message: str) => {
  let i = counter.inc();
  bucket.put("file-{i}.txt", message);
});
```

--------------------------------

### Run Local Documentation Website

Source: https://github.com/winglang/wing/blob/main/docs/contributing/01-start-here/08-docs.md

Execute this command from the repository root to start the local documentation website. It clones the docsite repository, symlinks your local copy, and launches the site in a browser.

```sh
pnpm docs
```

--------------------------------

### Implement a REST API with cloud.Api

Source: https://github.com/winglang/wing/blob/main/packages/@winglang/sdk/src/cloud/api.md

This example demonstrates a complete REST API implementation using cloud.Api, cloud.Bucket, and cloud.Counter. It defines routes for employee data management (GET, POST, PUT, DELETE). Ensure necessary imports are present.

```typescript
bring cloud;

let api = new cloud.Api();
// Used for generating unique id
let counter = new cloud.Counter();
// our employee data
let store = new cloud.Bucket();

api.get("/employees", inflight (request: cloud.ApiRequest): cloud.ApiResponse => {
  let result = MutJson [];
  let var i = 0;
  for employee in store.list() {
    result.setAt(i, employee);
    i = i + 1;
  }
  return cloud.ApiResponse {
    status: 200,
    body: Json.stringify(result)
  };
});


api.get("/employees/:id", inflight (request: cloud.ApiRequest): cloud.ApiResponse => {
  let employee = store.get(request.vars.get("id"));
  return cloud.ApiResponse {
    status: 200,
    body: Json.stringify(employee)
  };
});

api.post("/employees", inflight (request: cloud.ApiRequest): cloud.ApiResponse => {
   if let body = request.body {
    let employeeData = Json.parse(body);
    let id = "{counter.inc()}";
    store.putJson(id, employeeData);
    return cloud.ApiResponse {
      status: 201,
      body: id
    };
   }
});

api.put("/employees/:id", inflight (request: cloud.ApiRequest): cloud.ApiResponse => {
  if let body = request.body {
    let employeeData = Json.parse(body);
    let id = request.vars.get("id");
    store.putJson(id, employeeData);
    return cloud.ApiResponse {
      status: 200,
      body: Json.stringify(employeeData)
    };
  }
});

api.delete("/employees/:id", inflight (request: cloud.ApiRequest): cloud.ApiResponse => {
  let id = request.vars.get("id");
  store.delete(id);
  return cloud.ApiResponse {
    status: 204
  };
});

```

--------------------------------

### Build and Run a Container from Local Dockerfile

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/sim/container.md

This example demonstrates building a container from a local directory containing a Dockerfile. Ensure the './my-service' directory has a valid Dockerfile.

```js
new sim.Container(
  name: "my-service",
  image: "./my-service",
  containerPort: 8080,
);
```

--------------------------------

### Wing Preflight Assertion Example

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/assert.test.w_compile_tf-aws.md

This snippet demonstrates various assertion methods for string comparisons in Winglang. It includes checks for equality and inequality using direct strings and template literals. Ensure the Wing SDK is installed and configured for preflight execution.

```cjs
"use strict";
const $stdlib = require('@winglang/sdk');
const $macros = require("@winglang/sdk/lib/macros");
const $platforms = ((s) => !s ? [] : s.split(';'))(process.env.WING_PLATFORMS);
const $outdir = process.env.WING_SYNTH_DIR ?? ".";
const $wing_is_test = process.env.WING_IS_TEST === "true";
const std = $stdlib.std;
const $helpers = $stdlib.helpers;
const $extern = $helpers.createExternRequire(__dirname);
const $types = require("./types.cjs");
const $PlatformManager = new $stdlib.platform.PlatformManager({platformPaths: $platforms});
class $Root extends $stdlib.std.Resource {
  constructor($scope, $id) {
    super($scope, $id);
    $helpers.nodeof(this).root.$preflightTypesMap = { };
    let $preflightTypesMap = {};
    $helpers.nodeof(this).root.$preflightTypesMap = $preflightTypesMap;
    class $Closure1 extends $stdlib.std.AutoIdResource {
      _id = $stdlib.core.closureId();
      constructor($scope, $id, ) {
        super($scope, $id);
        $helpers.nodeof(this).hidden = true;
      }
      static _toInflightType() {
        return `
          require("${$helpers.normalPath(__dirname)}/inflight.$Closure1-1.cjs")({
            $s1: ${$stdlib.core.liftObject(s1)},
            $s2: ${$stdlib.core.liftObject(s2)},
          })
        `;
      }
      get _liftMap() {
        return ({
          "handle": [
            [s1, []],
            [s2, []],
          ],
          "$inflight_init": [
            [s1, []],
            [s2, []],
          ],
        });
      }
    }
    const s1 = "foo";
    const s2 = "bar";
    $helpers.assert($helpers.eq("", ""), "\"\" == \"\"");
    $helpers.assert($helpers.eq("\'", "\'", ), "\'\" == \'\"");
    $helpers.assert($helpers.eq("\"", "\"", ), "\"\" == \"\"");
    $helpers.assert($helpers.eq("`", "`"), "\`\" == \`\"");
    $helpers.assert($helpers.eq("``", "``"), "``\" == ``\"");
    $helpers.assert($helpers.eq("`s1`", "`s1`"), "\`s1\" == \`s1\"");
    $helpers.assert($helpers.eq(s1, s1), "s1 == s1");
    $helpers.assert($helpers.eq(String.raw({ raw: ["", ""] }, s1), String.raw({ raw: ["", ""] }, s1)), "\"{s1}\" == \"{s1}\"");
    $helpers.assert($helpers.neq(String.raw({ raw: ["", ""] }, s1), String.raw({ raw: ["", ""] }, s2)), "\"{s1}\" != \"{s2}\"");
    $helpers.assert($helpers.eq(String.raw({ raw: ["a", ""] }, s1), String.raw({ raw: ["a", ""] }, s1)), "a\"{s1}\" == a\"{s1}\"");
    $helpers.assert($helpers.neq(String.raw({ raw: ["a", ""] }, s1), String.raw({ raw: ["b", ""] }, s1)), "a\"{s1}\" != b\"{s1}\"");
    $helpers.assert($helpers.eq(String.raw({ raw: ["", "a"] }, s1), String.raw({ raw: ["", "a"] }, s1)), "\"{s1}a\" == \"{s1}a\"");
    $helpers.assert($helpers.neq(String.raw({ raw: ["", "a"] }, s1), String.raw({ raw: ["", "b"] }, s1)), "\"{s1}a\" != \"{s1}b\"");
    $helpers.assert($helpers.eq(String.raw({ raw: ["`'", ""] }, s1), String.raw({ raw: ["`'", ""] }, s1)), "\`\'\"{s1}\" == \`\'\"{s1}\"");
    $helpers.assert($helpers.eq(String.raw({ raw: ["a", "b", "c"] }, s1, s2), String.raw({ raw: ["a", "b", "c"] }, s1, s2)), "a\"{s1}b\"{s2}c\" == a\"{s1}b\"{s2}c\"");
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:assert works inflight", new $Closure1(this, "$Closure1"));
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "assert.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
//# sourceMappingURL=preflight.cjs.map
```

--------------------------------

### Wing Preflight Script with Mutable Data Structures

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/mut_container_types.test.w_compile_tf-aws.md

This script initializes and manipulates mutable arrays and maps, including operations like push, pop, at, add, has, get, set, and clear. It uses assertions to validate the outcomes of these operations. Ensure the Wing SDK is installed and configured for execution.

```cjs
"use strict";
const $stdlib = require('@winglang/sdk');
const $macros = require("@winglang/sdk/lib/macros");
const $platforms = ((s) => !s ? [] : s.split(';'))(process.env.WING_PLATFORMS);
const $outdir = process.env.WING_SYNTH_DIR ?? ".";
const $wing_is_test = process.env.WING_IS_TEST === "true";
const std = $stdlib.std;
const $helpers = $stdlib.helpers;
const $extern = $helpers.createExternRequire(__dirname);
const $types = require("./types.cjs");
const $PlatformManager = new $stdlib.platform.PlatformManager({platformPaths: $platforms});
class $Root extends $stdlib.std.Resource {
  constructor($scope, $id) {
    super($scope, $id);
    $helpers.nodeof(this).root.$preflightTypesMap = { };
    let $preflightTypesMap = {};
    const cloud = $stdlib.cloud;
    $helpers.nodeof(this).root.$preflightTypesMap = $preflightTypesMap;
    const bucket1 = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Bucket", cloud.Bucket, this, "bucket1");
    const bucket2 = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Bucket", cloud.Bucket, this, "bucket2");
    const bucket3 = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Bucket", cloud.Bucket, this, "bucket3");
    const arr1 = ["a", "b", "c"];
    const arr2 = [1, 2, 3];
    const arr3 = [bucket1, bucket2];
    const arr4 = arr1;
    $macros.__MutArray_push(false, arr1, "a");
    $macros.__MutArray_push(false, arr2, 4);
    $macros.__MutArray_push(false, arr3, bucket3);
    $helpers.assert($helpers.eq((arr2.pop()), 4), "arr2.pop() == 4");
    $helpers.assert($helpers.eq(arr1.length, 4), "arr1.length == 4");
    $helpers.assert($helpers.eq($macros.__MutArray_at(false, arr4, 0), "a"), "arr4.at(0) == \"a\"");
    const s1 = new Set([1, 2, 3, 3]);
    const s2 = new Set(["hello", "world", "hello"]);
    const s3 = new Set([bucket1, bucket2, bucket2]);
    (s1.add(5));
    (s2.add("bye"));
    (s3.add(bucket3));
    $helpers.assert((s2.has("bye")), "s2.has(\"bye\")");
    $helpers.assert((s2.has("hello")), "s2.has(\"hello\")");
    $helpers.assert((s3.has(bucket2)), "s3.has(bucket2)");
    const m1 = ({["hello"] : "world"});
    const m2 = ({["hello"] : 123});
    const m3 = ({["b1"] : bucket1, ["b2"] : bucket2});
    const m4 = m1;
    const m5 = ({["goodbye"] : "world"});
    const m6 = ({["a"] : m1, ["b"] : m5});
    $helpers.assert($macros.__MutMap_has(false, m1, "hello"), "m1.has(\"hello\")");
    $helpers.assert($helpers.eq($macros.__MutMap_size(false, m2, ), 1), "m2.size() == 1");
    $helpers.assert($helpers.eq($macros.__MutMap_get(false, m3, "b1"), bucket1), "m3.get(\"b1\") == bucket1");
    $helpers.assert($helpers.eq($macros.__MutMap_size(false, m4, ), 1), "m4.size() == 1");
    $helpers.assert($helpers.eq($macros.__MutMap_get(false, $macros.__MutMap_get(false, m6, "a"), "hello"), "world"), "m6.get(\"a\").get(\"hello\") == \"world\"");
    $macros.__MutMap_set(false, m1, "hello", "goodbye");
    $macros.__MutMap_set(false, m6, "a", ({["foo"] : "bar"}));
    $macros.__MutMap_clear(false, m2, );
    $helpers.assert($helpers.eq($macros.__MutMap_size(false, m2, ), 0), "m2.size() == 0");
    $helpers.assert($helpers.eq($macros.__MutMap_get(false, m1, "hello"), "goodbye"), "m1.get(\"hello\") == \"goodbye\"");
    $helpers.assert($helpers.eq($macros.__MutMap_get(false, $macros.__MutMap_get(false, m6, "a"), "foo"), "bar"), "m6.get(\"a\").get(\"foo\") == \"bar\"");
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "mut_container_types.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
//# sourceMappingURL=preflight.cjs.map
```

--------------------------------

### Wing Preflight Setup and Resource Instantiation

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/capture_resource_and_data.test.w_compile_tf-aws.md

This JavaScript code sets up the Winglang preflight environment, defines a test closure, and instantiates cloud resources like a bucket and a queue. It prepares the application for synthesis.

```cjs
"use strict";
const $stdlib = require('@winglang/sdk');
const $macros = require("@winglang/sdk/lib/macros");
const $platforms = ((s) => !s ? [] : s.split(';'))(process.env.WING_PLATFORMS);
const $outdir = process.env.WING_SYNTH_DIR ?? ".";
const $wing_is_test = process.env.WING_IS_TEST === "true";
const std = $stdlib.std;
const $helpers = $stdlib.helpers;
const $extern = $helpers.createExternRequire(__dirname);
const $types = require("./types.cjs");
const $PlatformManager = new $stdlib.platform.PlatformManager({platformPaths: $platforms});
class $Root extends $stdlib.std.Resource {
  constructor($scope, $id) {
    super($scope, $id);
    $helpers.nodeof(this).root.$preflightTypesMap = { };
    let $preflightTypesMap = {};
    const cloud = $stdlib.cloud;
    $helpers.nodeof(this).root.$preflightTypesMap = $preflightTypesMap;
    class $Closure1 extends $stdlib.std.AutoIdResource {
      _id = $stdlib.core.closureId();
      constructor($scope, $id, ) {
        super($scope, $id);
        $helpers.nodeof(this).hidden = true;
      }
      static _toInflightType() {
        return `
          require("${$helpers.normalPath(__dirname)}\/inflight.$Closure1-1.cjs")({
            $data: ${$stdlib.core.liftObject(data)},
            $queue: ${$stdlib.core.liftObject(queue)},
            $res: ${$stdlib.core.liftObject(res)},
          })
        `;
      }
      get _liftMap() {
        return ({
          "handle": [
            [data, ["size"]],
            [queue, ["push"]],
            [res, [].concat(["put"], ["get"])],
          ],
          "$inflight_init": [
            [data, []],
            [queue, []],
            [res, []],
          ],
        });
      }
    }
    const data = new Set([1, 2, 3]);
    const res = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Bucket", cloud.Bucket, this, "Bucket");
    const queue = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Queue", cloud.Queue, this, "Queue");
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:resource and data", new $Closure1(this, "$Closure1"));
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "capture_resource_and_data.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
//# sourceMappingURL=preflight.cjs.map
```

--------------------------------

### Initialize ApiPostOptions

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/api.md

Example of initializing the ApiPostOptions structure.

```wing
bring cloud;

let ApiPostOptions = cloud.ApiPostOptions{ ... };
```

--------------------------------

### Install Wing SDK

Source: https://github.com/winglang/wing/blob/main/packages/@winglang/sdk/README.md

Install the SDK package via npm.

```shell
npm i @winglang/sdk
```

--------------------------------

### Preflight Application Setup

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/bucket_keys.test.w_compile_tf-aws.md

Initializes the Winglang application and defines the test resource lifecycle.

```cjs
"use strict";
const $stdlib = require('@winglang/sdk');
const $macros = require("@winglang/sdk/lib/macros");
const $platforms = ((s) => !s ? [] : s.split(';'))(process.env.WING_PLATFORMS);
const $outdir = process.env.WING_SYNTH_DIR ?? ".";
const $wing_is_test = process.env.WING_IS_TEST === "true";
const std = $stdlib.std;
const $helpers = $stdlib.helpers;
const $extern = $helpers.createExternRequire(__dirname);
const $types = require("./types.cjs");
const $PlatformManager = new $stdlib.platform.PlatformManager({platformPaths: $platforms});
class $Root extends $stdlib.std.Resource {
  constructor($scope, $id) {
    super($scope, $id);
    $helpers.nodeof(this).root.$preflightTypesMap = { };
    let $preflightTypesMap = {};
    const cloud = $stdlib.cloud;
    $helpers.nodeof(this).root.$preflightTypesMap = $preflightTypesMap;
    class $Closure1 extends $stdlib.std.AutoIdResource {
      _id = $stdlib.core.closureId();
      constructor($scope, $id, ) {
        super($scope, $id);
        $helpers.nodeof(this).hidden = true;
      }
      static _toInflightType() {
        return `
          require("${$helpers.normalPath(__dirname)}/inflight.$Closure1-1.cjs")({
            $b: ${$stdlib.core.liftObject(b)},
          })
        `;
      }
      get _liftMap() {
        return ({
          "handle": [
            [b, [].concat(["put"], ["list"])],
          ],
          "$inflight_init": [
            [b, []],
          ],
        });
      }
    }
    const b = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Bucket", cloud.Bucket, this, "Bucket");
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:test", new $Closure1(this, "$Closure1"));
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "bucket_keys.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
//# sourceMappingURL=preflight.cjs.map
```

--------------------------------

### HTTP GET Request

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/http/api-reference.md

Executes a GET request to a specified URL.

```APIDOC
## GET http.get

### Description
Executes a GET request to a specified URL and provides a formatted response.

### Parameters
#### Path Parameters
- **url** (str) - Required - The target URL for the GET request.
- **options** (RequestOptions) - Optional - Optional parameters for customizing the GET request.
```

--------------------------------

### Create New Project

Source: https://github.com/winglang/wing/blob/main/docs/api/02-cli-user-manual.md

Initialize a new Wing project from a template.

```bash
$ wing new <template>
```

--------------------------------

### Example label value

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/endpoint.md

A simple string example for an endpoint label.

```wing
"My Dashboard"
```

--------------------------------

### Example Usage

Source: https://github.com/winglang/wing/blob/main/docs/contributing/999-rfcs/2023-01-20-wingsdk-spec.md

Demonstrates how to create an API Gateway, define routes, and handle requests.

```APIDOC
## Example Usage

### Creating an API Gateway and defining routes

```wing
let api = new cloud.Api();

api.get("/hello", inflight (req: cloud.ApiRequest): cloud.ApiResponse => {
  return cloud.ApiResponse {
    status: 200,
    body: "Hello, world!"
  };
});

api.post("/hello", inflight (req: cloud.ApiRequest): cloud.ApiResponse => {
  return cloud.ApiResponse {
    status: 200,
    body: "Hello, " + req.body + "!"
  };
});
```

### Example cURL commands

```bash
$ curl https://api.example.com/hello
Hello, world!

$ curl -X POST -d "world" https://api.example.com/hello
Hello, world!
```
```

--------------------------------

### GET /path

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/api.md

Registers an inflight handler for GET requests on a specified path.

```APIDOC
## GET [path]

### Description
Add an inflight handler to the api for GET requests on the given path.

### Method
GET

### Parameters
#### Path Parameters
- **path** (str) - Required - The path to handle GET requests for.
- **inflight** (IApiEndpointHandler) - Required - The function to handle the request.
- **props** (ApiGetOptions) - Optional - Options for the route.
```

--------------------------------

### Initialize WebsiteOptions

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/website.md

Basic initialization pattern for WebsiteOptions.

```wing
bring cloud;

let WebsiteOptions = cloud.WebsiteOptions{ ... };
```

--------------------------------

### Framework lift mechanism example

Source: https://github.com/winglang/wing/blob/main/docs/contributing/999-rfcs/2024-06-02-ts-client.md

An example of the lift mechanism as implemented in @wingcloud/framework.

```ts
const b = new cloud.Bucket(app, "Bucket");
const lifts = lift({ bucket }).grant({ bucket: ["put"] });
```

--------------------------------

### Initialize HTTP Url

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/http/api-reference.md

Shows how to instantiate a new http.Url object.

```wing
bring http;

let Url = http.Url{ ... };
```

--------------------------------

### Initialize configuration structs

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/secret.md

Examples for initializing GetSecretValueOptions and SecretProps.

```wing
bring cloud;

let GetSecretValueOptions = cloud.GetSecretValueOptions{ ... };
```

```wing
bring cloud;

let SecretProps = cloud.SecretProps{ ... };
```

--------------------------------

### Install Wing API Checker

Source: https://github.com/winglang/wing/blob/main/packages/wing-api-checker/README.md

Installs the CLI tool globally using npm.

```bash
npm install -g wing-api-checker
```

--------------------------------

### Install WebSocket Library

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

Install the required dependency for WebSocket functionality in the backend directory.

```sh
cd ~/shared-counter/backend
npm i @winglibs/websockets
```

--------------------------------

### Initialize a Queue

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/queue.md

Basic syntax for instantiating a new queue resource.

```wing
bring cloud;

new cloud.Queue(props?: QueueProps);
```

--------------------------------

### Initialize ExecOptions

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/util/api-reference.md

Create an instance of ExecOptions for configuring util.exec().

```wing
bring util;

let ExecOptions = util.ExecOptions{ ... };
```

--------------------------------

### Install Winglibs Package

Source: https://github.com/winglang/wing/blob/main/docs/typescript/03-ecosystem.md

Install trusted libraries from the winglibs ecosystem using npm.

```shell
npm install @winglibs/checks
```

--------------------------------

### Use Datetime Examples

Source: https://github.com/winglang/wing/blob/main/docs/contributing/999-rfcs/2023-06-12-language-spec.md

Demonstrates creating Datetime instances and accessing properties like timezone and UTC conversion.

```js
let now = Datetime.utcNow();
log("It is now ${now.month}/${now.day}/${now.year} at ${now.hours}:${now.min}:${now.sec})");
assert(now.timezone == 0); // UTC

let t1 = DateTime.fromIso("2023-02-09T06:20:17.573Z");
log("Timezone is GMT${d.timezone() / 60}"); // output: Timezone is GMT-2
log("UTC: ${t1.utc.toIso())}");            // output: 2023-02-09T06:21:03.000Z
```

--------------------------------

### Test failure example

Source: https://github.com/winglang/wing/blob/main/docs/docs/02-concepts/04-tests.md

Example demonstrating how an explicit exception causes a test to fail.

```ts
// example.w
bring cloud;

let b = new cloud.Bucket();

test "bucket list should include created file" {
  b.put("file", "lorem ipsum");
  let listOfFile = b.list();
  assert(listOfFile.length == 1);
}

test "bucket starts empty" {
  let listOfFile = b.list();
  assert(listOfFile.length == 0);
}

test "this test should fail" {
  throw "test throws an exception fails";
}
```

--------------------------------

### Initializing ScheduleProps

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/schedule.md

Demonstrates how to initialize the configuration options for a Schedule.

```wing
bring cloud;

let ScheduleProps = cloud.ScheduleProps{ ... };
```

--------------------------------

### Wing Preflight Script Setup

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/phase_independent_method_on_string.test.w_compile_tf-aws.md

This script initializes the Winglang SDK, loads necessary modules, and configures platform and output directory settings. It defines the root construct for the application and prepares the testing environment.

```cjs
"use strict";
const $stdlib = require('@winglang/sdk');
const $macros = require("@winglang/sdk/lib/macros");
const $platforms = ((s) => !s ? [] : s.split(';'))(process.env.WING_PLATFORMS);
const $outdir = process.env.WING_SYNTH_DIR ?? ".";
const $wing_is_test = process.env.WING_IS_TEST === "true";
const std = $stdlib.std;
const $helpers = $stdlib.helpers;
const $extern = $helpers.createExternRequire(__dirname);
const $types = require("./types.cjs");
const $PlatformManager = new $stdlib.platform.PlatformManager({platformPaths: $platforms});
class $Root extends $stdlib.std.Resource {
  constructor($scope, $id) {
    super($scope, $id);
    $helpers.nodeof(this).root.$preflightTypesMap = { };
    let $preflightTypesMap = {};
    const cloud = $stdlib.cloud;
    const expect = $stdlib.expect;
    $helpers.nodeof(this).root.$preflightTypesMap = $preflightTypesMap;
    class $Closure1 extends $stdlib.std.AutoIdResource {
      _id = $stdlib.core.closureId();
      constructor($scope, $id, ) {
        super($scope, $id);
        $helpers.nodeof(this).hidden = true;
      }
      static _toInflightType() {
        return `
          require("${$helpers.normalPath(__dirname)}/inflight.$Closure1-1.cjs")({
            $api_url: ${$stdlib.core.liftObject(api.url)},
            $expect_Util: ${$stdlib.core.liftObject($stdlib.core.toLiftableModuleType(globalThis.$ClassFactory.resolveType("@winglang/sdk.expect.Util") ?? expect.Util, "@winglang/sdk/expect", "Util"))},
            $tokenLength: ${$stdlib.core.liftObject(tokenLength)},
            $urlRegex: ${$stdlib.core.liftObject(urlRegex)},
          })
        `;
      }
      get _liftMap() {
        return ({
          "handle": [
            [$stdlib.core.toLiftableModuleType(globalThis.$ClassFactory.resolveType("@winglang/sdk.expect.Util") ?? expect.Util, "@winglang/sdk/expect", "Util"), [].concat(["equal"], ["notEqual"])],
            [api.url, [].concat(["startsWith"], ["length"])],
            [tokenLength, []],
            [urlRegex, ["test"]],
          ],
          "$inflight_init": [
            [$stdlib.core.toLiftableModuleType(globalThis.$ClassFactory.resolveType("@winglang/sdk.expect.Util") ?? expect.Util, "@winglang/sdk/expect", "Util"), []],
            [api.url, []],
            [tokenLength, []],
            [urlRegex, []],
          ],
        });
      }
    }
    const api = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Api", cloud.Api, this, "Api");
    const urlRegex = (std.Regex.compile("https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256\\}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)"));
    (expect.Util.equal((urlRegex.test(api.url)), false));
    const tokenLength = api.url.length;
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:phase independent method on string evaluated inflight", new $Closure1(this, "$Closure1"));
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "phase_independent_method_on_string.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
//# sourceMappingURL=preflight.cjs.map

```

--------------------------------

### Install Wing Console App

Source: https://github.com/winglang/wing/blob/main/wing-console/console/app/README.md

Install the Wing Console application package using npm.

```sh
npm i @wingconsole/app
```

--------------------------------

### Install Redis Winglib

Source: https://github.com/winglang/wing/blob/main/docs/docs/04-winglibs/02-using-winglibs.md

Install the Redis Winglib using npm. This command is run in your terminal.

```bash
npm i @winglibs/redis
```

--------------------------------

### Initialize WriteFileOptions

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/fs/api-reference.md

Shows the initialization pattern for file writing configuration.

```wing
bring fs;

let WriteFileOptions = fs.WriteFileOptions{ ... };
```

--------------------------------

### Constructor: new cloud.Website

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/website.md

Initializes a new static website resource.

```APIDOC
## new cloud.Website

### Description
Creates a new cloud static website instance.

### Parameters
#### Path Parameters
- **props** (WebsiteProps) - Required - Configuration properties for the website.
```

--------------------------------

### Clone and Install Dependencies

Source: https://github.com/winglang/wing/blob/main/docs/contributing/01-start-here/05-development.md

Clone the Wing repository and install project dependencies using PNPM.

```sh
git clone https://github.com/winglang/wing
cd wing
pnpm install
```

--------------------------------

### Full main.w Implementation

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

Complete configuration for the main application file including API, counter, and broadcaster integration.

```ts
bring vite;
bring cloud;
bring "./broadcaster.w" as b;

let broadcaster = new b.Broadcaster();

let api = new cloud.Api(cors: true);
let counter = new cloud.Counter();

api.get("/counter", inflight () => {
  return {
    body: "{counter.peek()}"
  };
});

api.post("/counter", inflight () => {
  let prev = counter.inc();
  broadcaster.broadcast("refresh");
  return {
    body: "{prev + 1}"
  };
});

new vite.Vite(
  root: "../frontend",
  publicEnv: {
    TITLE: "Wing + Vite + React",
    WS_URL: broadcaster.url,
    API_URL: api.url,
  }
);
```

--------------------------------

### Install @winglibs/vite

Source: https://github.com/winglang/wing/blob/main/docs/docs/08-guides/03-react-vite-websockets.md

Install the Vite library for your Wing project using npm. Ensure you are in the backend directory.

```sh
cd ~/shared-counter/backend
npm i @winglibs/vite
```

--------------------------------

### View available platforms

Source: https://github.com/winglang/wing/blob/main/docs/docs/03-platforms/01-understanding-platforms.md

Use the help command to list builtin platform providers.

```sh
wing compile --help
Usage: wing compile [options] [entrypoint]

Compiles a Wing program

Arguments:
  entrypoint                    program .w entrypoint

Options:
  -t, --platform <platform> --platform <platform>  Target platform provider (builtin: sim, tf-aws, tf-azure, tf-gcp) (default: [sim])
  -h, --help                    display help for command
```

--------------------------------

### Application Synthesis and Resource Instantiation

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/new_in_static.test.w_compile_tf-aws.md

Example of initializing a Winglang application and instantiating resources within the root construct.

```cjs
$helpers.assert($helpers.eq((jsii_fixture.JsiiClass.staticMethod("foo")), "Got foo"), "jsii_fixture.JsiiClass.staticMethod(\"foo\") == \"Got foo\"");
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:play with buckets", new $Closure1(this, "$Closure1"));
    const f = new Foo(this, "Foo");
    const lib_f = (new_in_static_lib.LibClass.createFoo(this, "lib-foo"));
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "new_in_static.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
//# sourceMappingURL=preflight.cjs.map
```

--------------------------------

### Instantiate Resources and Run Tests

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/class.test.w_compile_tf-aws.md

Demonstrates instantiating classes and registering test cases within the application root.

```javascript
    new C1(this, "C1");
    const c2 = new C2(this, "C2");
    $helpers.assert($helpers.eq(c2.x, 1), "c2.x == 1");
    const c2Ext1 = new C2Ext1(this, "C2Ext1");
    $helpers.assert($helpers.eq(c2Ext1.x, 1), "c2Ext1.x == 1");
    const c2Ext2 = new C2Ext2(this, "C2Ext2");
    $helpers.assert($helpers.eq(c2Ext2.x, 1), "c2Ext2.x == 1");
    const c2Ext3 = new C2Ext3(this, "C2Ext3");
    $helpers.assert($helpers.eq(c2Ext3.x, 1), "c2Ext3.x == 1");
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:inflight classes with no ctor or ctor args", new $Closure1(this, "$Closure1"));
    const c3 = new C3(this, "C3", 1, 2);
    $helpers.assert($helpers.eq(c3.x, 1), "c3.x == 1");
    $helpers.assert($helpers.eq(c3.y, 2), "c3.y == 2");
    $helpers.assert($helpers.eq((C4.m(this)), 1), "C4.m() == 1");
    const c5 = new C5(this, "C5");
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:access inflight field", new $Closure2(this, "$Closure2"));
    const student = new PaidStudent(this, "PaidStudent", "Tom", "MySpace", 38);
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:check derived class instance variables", new $Closure3(this, "$Closure3"));
    const ta = new TeacherAid(this, "TeacherAid", "John", "Rock'n Roll", 50);
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:devived class init body happens after super", new $Closure4(this, "$Closure4"));
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:inflight super constructor", new $Closure5(this, "$Closure5"));
    new Foo(this, "Foo");
    new Baz(this, "Baz");
```

--------------------------------

### Install Wing Library with npm

Source: https://github.com/winglang/wing/blob/main/docs/docs/04-winglibs/01-what-are-winglibs.md

Use this command to install a Wing library, such as wing-redis, using npm.

```bash
npm i wing-redis
```

--------------------------------

### Initialize Application and Resources

Source: https://github.com/winglang/wing/blob/main/tools/hangar/__snapshots__/test_corpus/valid/resource_captures.test.w_compile_tf-aws.md

Instantiates the application, resources, and test constructs.

```javascript
const b = globalThis.$ClassFactory.new("@winglang/sdk.cloud.Bucket", cloud.Bucket, this, "Bucket");
    const r = new MyResource(this, "MyResource", b, 12);
    globalThis.$ClassFactory.new("@winglang/sdk.std.Test", std.Test, this, "test:test", new $Closure1(this, "$Closure1"));
  }
}
const $APP = $PlatformManager.createApp({ outdir: $outdir, name: "resource_captures.test", rootConstruct: $Root, isTestEnvironment: $wing_is_test, entrypointDir: process.env['WING_SOURCE_DIR'], rootId: process.env['WING_ROOT_ID'] });
$APP.synth();
```

--------------------------------

### Example Domain Name String in Winglang

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/domain.md

An example of a valid string literal for a custom domain name.

```wing
"example.com"
```

--------------------------------

### Install Wing CLI

Source: https://github.com/winglang/wing/blob/main/docs/contributing/03-stories/story-16.md

Install the Wing Cloud CLI using npm. This is a prerequisite for running Wing applications.

```sh
npm i winglang
```

--------------------------------

### Instantiate AWS Website

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/aws/api-reference.md

Initializes a new AWS Website resource with the provided properties. Ensure `WebsiteProps` are correctly configured.

```wing
bring aws;

new aws.Website(props: WebsiteProps);
```

--------------------------------

### Execute GET Request

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/http/api-reference.md

Executes a GET request to a specified URL. Use this for retrieving data from a given endpoint.

```wing
bring http;

inflight http.get(url: str, options?: RequestOptions);
```

--------------------------------

### Simple Pub-Sub Example

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/topic.md

Combines topic creation, an inflight consumer handler, and an inflight publisher handler invoked by a cloud.Function. This demonstrates a basic event-driven flow.

```javascript
bring cloud;

// First we create a topic
let topic = new cloud.Topic();

// Then we define a consumer inflight handler
let consumerHandler = inflight(message: str) => {
  log("Doing some work with message: {message}");
};

// Now we can use a preflight method of topic to register the consumer handler
// to be invoked when a message is published to the topic.
topic.onMessage(consumerHandler);

// Then we define the producer inflight handler
let publisherHandler = inflight () => {
  // Here we use the inflight api to publish a message to the topic.
  topic.publish("Here are those launch codes you asked for.");
};

// Finally we can use multiple resources to invoke our publisher handler
// for simplicity sake we will just use a function.
new cloud.Function(publisherHandler);
```

--------------------------------

### Wing console output example

Source: https://github.com/winglang/wing/blob/main/docs/by-example/25-random.md

Example output generated by running the random number code in the Wing console.

```bash
# Run locally with wing console, output will vary
46.58171364582826
4
5.721934646951212
```

--------------------------------

### Initialize API Head Options

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/api.md

Example of initializing the ApiHeadOptions structure.

```wing
bring cloud;

let ApiHeadOptions = cloud.ApiHeadOptions{ ... };
```

--------------------------------

### Initialize MkdirOptions Object

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/fs/api-reference.md

Create a new instance of the directory creation options object.

```wing
bring fs;

let MkdirOptions = fs.MkdirOptions{ ... };
```

--------------------------------

### Control Service Auto-Start

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/service.md

Determine if the service should start automatically. If false, manual start is required. Defaults to true.

```wing
autoStart: bool;
```

--------------------------------

### Install AWS CDK and Wing Platform

Source: https://github.com/winglang/wing/blob/main/docs/docs/03-platforms/02-AWS/awscdk.md

Commands to install the necessary dependencies for AWS CDK and the Wing awscdk platform.

```sh
npm i aws-cdk
```

```sh
npm i @winglang/platform-awscdk
```

--------------------------------

### Initialize Queue Set Consumer Options

Source: https://github.com/winglang/wing/blob/main/docs/api/04-standard-library/cloud/queue.md

Initializes options for setting up a queue consumer. The 'cloud' module must be imported.

```wing
bring cloud;

let QueueSetConsumerOptions = cloud.QueueSetConsumerOptions{ ... };
```
Tokens:
Raw