@awsless/awsless 0.0.34 → 0.0.36

package/dist/bin.js

@@ -998,7 +998,145 @@ var hasOnFailure = (config) => {
 };
 
 // src/plugins/function.ts
+import { camelCase as camelCase2 } from "change-case";
+
+// src/util/path.ts
+import { lstat } from "fs/promises";
+import { join, normalize } from "path";
+var root = process.cwd();
+var directories = {
+  root,
+  get output() {
+    return join(this.root, ".awsless");
+  },
+  get cache() {
+    return join(this.output, "cache");
+  },
+  get asset() {
+    return join(this.output, "asset");
+  },
+  get types() {
+    return join(this.output, "types");
+  },
+  get template() {
+    return join(this.output, "template");
+  }
+};
+var setRoot = (path = root) => {
+  directories.root = path;
+};
+var findRootDir = async (path, configFile, level = 5) => {
+  if (!level) {
+    throw new TypeError("No awsless project found");
+  }
+  const file = join(path, configFile);
+  const exists = await fileExist(file);
+  if (exists) {
+    return path;
+  }
+  return findRootDir(normalize(join(path, "..")), configFile, level - 1);
+};
+var fileExist = async (file) => {
+  try {
+    const stat = await lstat(file);
+    if (stat.isFile()) {
+      return true;
+    }
+  } catch (error) {
+  }
+  return false;
+};
+
+// src/plugins/function.ts
+import { relative as relative2 } from "path";
+
+// src/util/type-gen.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join as join2, relative } from "path";
 import { camelCase } from "change-case";
+var generateResourceTypes = async (config) => {
+  const plugins = [
+    ...defaultPlugins,
+    ...config.plugins || []
+  ];
+  const files = [];
+  for (const plugin of plugins) {
+    const code = plugin.onTypeGen?.({ config });
+    if (code) {
+      const file = join2(directories.types, `${plugin.name}.d.ts`);
+      files.push(relative(directories.root, file));
+      await mkdir(directories.types, { recursive: true });
+      await writeFile(file, code);
+    }
+  }
+  if (files.length) {
+    const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
+    await writeFile(join2(directories.root, `awsless.d.ts`), code);
+  }
+};
+var TypeGen = class {
+  constructor(module, interfaceName) {
+    this.module = module;
+    this.interfaceName = interfaceName;
+  }
+  codes = /* @__PURE__ */ new Set();
+  types = /* @__PURE__ */ new Map();
+  imports = /* @__PURE__ */ new Map();
+  addImport(varName, path) {
+    this.imports.set(varName, path);
+    return this;
+  }
+  addCode(code) {
+    this.codes.add(code);
+    return this;
+  }
+  addType(name, type) {
+    if (type) {
+      this.types.set(name, type);
+    }
+    return this;
+  }
+  toString() {
+    if (this.types.size === 0) {
+      return;
+    }
+    const imports = Array.from(this.imports.entries()).map(([varName, path]) => {
+      return `import ${camelCase(varName)} from '${path}'`;
+    }).join("\n");
+    return [
+      imports,
+      ...Array.from(this.codes),
+      `declare module '${this.module}' {`,
+      `	interface ${this.interfaceName} {`,
+      ...Array.from(this.types.entries()).map(([propName, type]) => {
+        return `		readonly ${camelCase(propName)}: ${type}`;
+      }),
+      `	}`,
+      `}`
+    ].join("\n");
+  }
+};
+var TypeObject = class {
+  types = /* @__PURE__ */ new Map();
+  addType(name, type) {
+    this.types.set(name, type);
+    return this;
+  }
+  toString() {
+    if (!this.types.size) {
+      return "";
+    }
+    return [
+      "{",
+      ...Array.from(this.types.entries()).map(([propName, type]) => {
+        return `			readonly ${camelCase(propName)}: ${type}`;
+      }),
+      "		}"
+    ].join("\n");
+  }
+};
+
+// src/plugins/function.ts
 var MemorySizeSchema = SizeSchema.refine(sizeMin(Size.megaBytes(128)), "Minimum memory size is 128 MB").refine(sizeMax(Size.gigaBytes(10)), "Minimum memory size is 10 GB");
 var TimeoutSchema = DurationSchema.refine(durationMin(Duration.seconds(10)), "Minimum timeout duration is 10 seconds").refine(durationMax(Duration.minutes(15)), "Maximum timeout duration is 15 minutes");
 var EphemeralStorageSizeSchema = SizeSchema.refine(sizeMin(Size.megaBytes(512)), "Minimum ephemeral storage size is 512 MB").refine(sizeMax(Size.gigaBytes(10)), "Minimum ephemeral storage size is 10 GB");
@@ -1133,48 +1271,33 @@ var schema = z6.object({
     ).optional()
   }).array()
 });
+var typeGenCode = `
+import { InvokeOptions } from '@awsless/lambda'
+
+type Invoke<Name extends string, Func extends (...args: any[]) => any> = {
+	name: Name
+	invoke: (event: Parameters<Func>[0], options?: Omit<InvokeOptions, 'name' | 'payload'>) => ReturnType<Func>
+	async: (event: Parameters<Func>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>) => ReturnType<Func>
+}`;
 var functionPlugin = definePlugin({
   name: "function",
   schema,
   onTypeGen({ config }) {
-    const imports = [];
-    const props = [];
+    const types2 = new TypeGen("@awsless/awsless", "FunctionResources");
+    types2.addCode(typeGenCode);
     for (const stack of config.stacks) {
-      const functions = [];
+      const list3 = new TypeObject();
       for (const [name, fileOrProps] of Object.entries(stack.functions || {})) {
-        const varName = camelCase(`${stack.name}-${name}`);
+        const varName = camelCase2(`${stack.name}-${name}`);
+        const funcName = formatName(`${config.name}-${stack.name}-${name}`);
         const file = typeof fileOrProps === "string" ? fileOrProps : fileOrProps.file;
-        imports.push(`import ${varName} from '${file}'`);
-        functions.push(`			readonly ${camelCase(name)}: Invoke<typeof ${varName}>`);
-      }
-      if (functions.length > 0) {
-        props.push(`		readonly ${camelCase(stack.name)}: {
- ${functions.join("\n")}
-		}`);
+        const relFile = relative2(directories.types, file);
+        types2.addImport(varName, relFile);
+        list3.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
       }
+      types2.addType(stack.name, list3.toString());
     }
-    if (imports.length === 0) {
-      return;
-    }
-    return (
-      /* TS */
-      `
-${imports.join("\n")}
-
-import { InvokeOptions } from '@awsless/lambda'
-
-type Options = Omit<InvokeOptions, 'name' | 'payload'>
-
-type Invoke<Func extends (...args: any[]) => any> = {
-	(event: Parameters<Func>[0], options?: Options): ReturnType<Func>
-}
-
-declare module '@awsless/awsless' {
-	interface FunctionResources {
-${props.join("\n")}
-	}
-}`
-    );
+    return types2.toString();
   },
   onStack(ctx) {
     const { config, stack } = ctx;
@@ -1575,6 +1698,18 @@ var queuePlugin = definePlugin({
       ).optional()
     }).array()
   }),
+  onTypeGen({ config }) {
+    const types2 = new TypeGen("@awsless/awsless", "QueueResources");
+    for (const stack of config.stacks) {
+      const list3 = new TypeObject();
+      for (const name of Object.keys(stack.queues || {})) {
+        const queueName = formatName(`${config.name}-${stack.name}-${name}`);
+        list3.addType(name, `{ name: '${queueName}' }`);
+      }
+      types2.addType(stack.name, list3.toString());
+    }
+    return types2.toString();
+  },
   onStack(ctx) {
     const { stack, config, stackConfig, bind } = ctx;
     for (const [id, functionOrProps] of Object.entries(stackConfig.queues || {})) {
@@ -1848,6 +1983,18 @@ var tablePlugin = definePlugin({
       ).optional()
     }).array()
   }),
+  onTypeGen({ config }) {
+    const types2 = new TypeGen("@awsless/awsless", "TableResources");
+    for (const stack of config.stacks) {
+      const list3 = new TypeObject();
+      for (const name of Object.keys(stack.tables || {})) {
+        const tableName = formatName(`${config.name}-${stack.name}-${name}`);
+        list3.addType(name, `{ name: '${tableName}' }`);
+      }
+      types2.addType(stack.name, list3.toString());
+    }
+    return types2.toString();
+  },
   onStack(ctx) {
     const { config, stack, stackConfig, bind } = ctx;
     for (const [id, props] of Object.entries(stackConfig.tables || {})) {
@@ -2034,6 +2181,16 @@ var topicPlugin = definePlugin({
       topics: z11.record(ResourceIdSchema, FunctionSchema).optional()
     }).array()
   }),
+  onTypeGen({ config }) {
+    const gen = new TypeGen("@awsless/awsless", "TopicResources");
+    for (const stack of config.stacks) {
+      for (const topic of Object.keys(stack.topics || {})) {
+        const name = formatName(`${config.name}-${topic}`);
+        gen.addType(topic, `{ name: '${name}' }`);
+      }
+    }
+    return gen.toString();
+  },
   onApp({ config, bootstrap: bootstrap2, bind }) {
     const allTopicNames = config.stacks.map((stack) => {
       return Object.keys(stack.topics || {});
@@ -4088,7 +4245,7 @@ var toApp = async (config, filters) => {
 };
 
 // src/config.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/util/account.ts
 import { STSClient, GetCallerIdentityCommand } from "@aws-sdk/client-sts";
@@ -4172,60 +4329,12 @@ var AppSchema = z23.object({
 });
 
 // src/util/import.ts
-import { rollup as rollup2 } from "rollup";
+import { rollup as rollup2, watch } from "rollup";
 import { swc as swc2 } from "rollup-plugin-swc3";
 import replace from "rollup-plugin-replace";
-import { dirname as dirname2, join as join2 } from "path";
-import { mkdir, writeFile } from "fs/promises";
-
-// src/util/path.ts
-import { lstat } from "fs/promises";
-import { join, normalize } from "path";
-var root = process.cwd();
-var directories = {
-  root,
-  get output() {
-    return join(this.root, ".awsless");
-  },
-  get cache() {
-    return join(this.output, "cache");
-  },
-  get asset() {
-    return join(this.output, "asset");
-  },
-  get types() {
-    return join(this.output, "types");
-  },
-  get template() {
-    return join(this.output, "template");
-  }
-};
-var setRoot = (path = root) => {
-  directories.root = path;
-};
-var findRootDir = async (path, configFile, level = 5) => {
-  if (!level) {
-    throw new TypeError("No awsless project found");
-  }
-  const file = join(path, configFile);
-  const exists = await fileExist(file);
-  if (exists) {
-    return path;
-  }
-  return findRootDir(normalize(join(path, "..")), configFile, level - 1);
-};
-var fileExist = async (file) => {
-  try {
-    const stat = await lstat(file);
-    if (stat.isFile()) {
-      return true;
-    }
-  } catch (error) {
-  }
-  return false;
-};
-
-// src/util/import.ts
+import { EventIterator } from "event-iterator";
+import { dirname as dirname2, join as join3 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 var importFile = async (path) => {
   const bundle = await rollup2({
     input: path,
@@ -4244,18 +4353,73 @@ var importFile = async (path) => {
       })
     ]
   });
-  const outputFile = join2(directories.cache, "config.js");
+  const outputFile = join3(directories.cache, "config.js");
   const result = await bundle.generate({
     format: "esm",
     exports: "default"
   });
   const output = result.output[0];
   const code = output.code;
-  await mkdir(directories.cache, { recursive: true });
-  await writeFile(outputFile, code);
+  await mkdir2(directories.cache, { recursive: true });
+  await writeFile2(outputFile, code);
   debug("Save config file:", style.info(outputFile));
   return import(outputFile);
 };
+var watchFile = (path) => {
+  return new EventIterator((queue2) => {
+    const watcher = watch({
+      watch: {
+        skipWrite: true
+      },
+      input: path,
+      onwarn: (error) => {
+        debugError(error.message);
+      },
+      plugins: [
+        replace({
+          __dirname: (id) => `'${dirname2(id)}'`
+        }),
+        swc2({
+          minify: false,
+          jsc: {
+            baseUrl: dirname2(path)
+          }
+        })
+      ]
+    });
+    let resume;
+    queue2.on("lowWater", () => {
+      resume?.(true);
+    });
+    watcher.on("close", queue2.stop);
+    watcher.on("event", async (event) => {
+      if (event.code === "ERROR") {
+        queue2.fail(new Error(event.error.message));
+      }
+      if (event.code === "BUNDLE_END") {
+        const result = await event.result.generate({
+          format: "esm",
+          exports: "default"
+        });
+        event.result.close();
+        const output = result.output[0];
+        const code = output.code;
+        const outputFile = join3(directories.cache, "config.js");
+        await mkdir2(directories.cache, { recursive: true });
+        await writeFile2(outputFile, code);
+        debug("Save config file:", style.info(outputFile));
+        const config = await import(`${outputFile}?${Date.now()}`);
+        queue2.push(config);
+      }
+    });
+    return () => {
+      watcher.close();
+    };
+  }, {
+    highWaterMark: 1,
+    lowWaterMark: 0
+  });
+};
 
 // src/config.ts
 var importConfig = async (options) => {
@@ -4265,7 +4429,7 @@ var importConfig = async (options) => {
   setRoot(root2);
   debug("CWD:", style.info(root2));
   debug("Import config file");
-  const fileName = join3(root2, configFile);
+  const fileName = join4(root2, configFile);
   const module = await importFile(fileName);
   const appConfig = typeof module.default === "function" ? await module.default(options) : module.default;
   debug("Validate config file");
@@ -4291,6 +4455,40 @@ var importConfig = async (options) => {
     credentials
   };
 };
+var watchConfig = async function* (options) {
+  debug("Find the root directory");
+  const configFile = options.configFile || "awsless.config.ts";
+  const root2 = await findRootDir(process.cwd(), configFile);
+  setRoot(root2);
+  debug("CWD:", style.info(root2));
+  debug("Import config file");
+  const fileName = join4(root2, configFile);
+  for await (const module of watchFile(fileName)) {
+    const appConfig = typeof module.default === "function" ? await module.default(options) : module.default;
+    debug("Validate config file");
+    const plugins = [
+      ...defaultPlugins,
+      ...appConfig.plugins || []
+    ];
+    let schema2 = AppSchema;
+    for (const plugin of plugins) {
+      if (plugin.schema) {
+        schema2 = schema2.and(plugin.schema);
+      }
+    }
+    const config = await schema2.parseAsync(appConfig);
+    debug("Load credentials", style.info(config.profile));
+    const credentials = getCredentials(config.profile);
+    debug("Load AWS account ID");
+    const account = await getAccountId(credentials, config.region);
+    debug("Account ID:", style.info(account));
+    yield {
+      ...config,
+      account,
+      credentials
+    };
+  }
+};
 
 // src/cli/ui/layout/basic.ts
 var br = () => {
@@ -4766,7 +4964,7 @@ var layout = async (cb) => {
 };
 
 // src/cli/ui/complex/builder.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 
 // src/cli/ui/layout/flex-line.ts
 var stripEscapeCode = (str) => {
@@ -4789,7 +4987,7 @@ var flexLine = (term, left, right, reserveSpace = 0) => {
 };
 
 // src/cli/ui/complex/builder.ts
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 var assetBuilder = (app) => {
   return async (term) => {
     const assets = [];
@@ -4852,10 +5050,10 @@ var assetBuilder = (app) => {
         try {
           const data = await asset.build({
             async write(file, data2) {
-              const fullpath = join4(directories.asset, asset.type, app.name, stack.name, asset.id, file);
+              const fullpath = join5(directories.asset, asset.type, app.name, stack.name, asset.id, file);
               const basepath = dirname3(fullpath);
-              await mkdir2(basepath, { recursive: true });
-              await writeFile2(fullpath, data2);
+              await mkdir3(basepath, { recursive: true });
+              await writeFile3(fullpath, data2);
             }
           });
           details.set({
@@ -4879,7 +5077,7 @@ var assetBuilder = (app) => {
 };
 
 // src/util/cleanup.ts
-import { mkdir as mkdir3, rm } from "fs/promises";
+import { mkdir as mkdir4, rm } from "fs/promises";
 var cleanUp = async () => {
   debug("Clean up template, cache, and asset files");
   const paths = [
@@ -4893,45 +5091,28 @@ var cleanUp = async () => {
     force: true,
     maxRetries: 2
   })));
-  await Promise.all(paths.map((path) => mkdir3(path, {
+  await Promise.all(paths.map((path) => mkdir4(path, {
     recursive: true
   })));
 };
 
 // src/cli/ui/complex/template.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
+import { join as join6 } from "path";
 var templateBuilder = (app) => {
   return async (term) => {
     const done = term.out.write(loadingDialog("Building stack templates..."));
     await Promise.all(app.stacks.map(async (stack) => {
       const template = stack.toString(true);
-      const path = join5(directories.template, app.name);
-      const file = join5(path, `${stack.name}.json`);
-      await mkdir4(path, { recursive: true });
-      await writeFile3(file, template);
+      const path = join6(directories.template, app.name);
+      const file = join6(path, `${stack.name}.json`);
+      await mkdir5(path, { recursive: true });
+      await writeFile4(file, template);
     }));
     done("Done building stack templates");
   };
 };
 
-// src/util/type-gen.ts
-import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { join as join6 } from "path";
-var generateResourceTypes = async (config) => {
-  const plugins = [
-    ...defaultPlugins,
-    ...config.plugins || []
-  ];
-  for (const plugin of plugins) {
-    const code = plugin.onTypeGen?.({ config });
-    if (code) {
-      await mkdir5(directories.types, { recursive: true });
-      await writeFile4(join6(directories.types, `${plugin.name}.d.ts`), code);
-    }
-  }
-};
-
 // src/cli/ui/complex/types.ts
 var typesGenerator = (config) => {
   return async (term) => {
@@ -5723,6 +5904,19 @@ var types = (program2) => {
   });
 };
 
+// src/cli/command/dev.ts
+var dev = (program2) => {
+  program2.command("dev").description("Start the development service").action(async () => {
+    await layout(async (_, write) => {
+      const options = program2.optsWithGlobals();
+      for await (const config of watchConfig(options)) {
+        await cleanUp();
+        await write(typesGenerator(config));
+      }
+    });
+  });
+};
+
 // src/cli/program.ts
 var program = new Command();
 program.name(logo().join("").replace(/\s+/, ""));
@@ -5744,6 +5938,7 @@ var commands2 = [
   types,
   build,
   deploy,
+  dev,
   secrets,
   test
   // diff,

package/dist/index.cjs

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Function: () => Function,
+  Queue: () => Queue,
   Table: () => Table,
+  Topic: () => Topic,
   defineAppConfig: () => defineAppConfig,
   definePlugin: () => definePlugin,
   defineStackConfig: () => defineStackConfig,
@@ -46,15 +48,13 @@ var import_change_case = require("change-case");
 var APP = process.env.APP || "app";
 var STACK = process.env.STACK || "stack";
 var getLocalResourceName = (name, stack = STACK) => {
-  return `${APP}--${(0, import_change_case.paramCase)(stack)}--${(0, import_change_case.paramCase)(name)}`;
+  return `${APP}-${(0, import_change_case.paramCase)(stack)}-${(0, import_change_case.paramCase)(name)}`;
 };
 var getGlobalResourceName = (name) => {
-  return `${APP}--${(0, import_change_case.paramCase)(name)}`;
+  return `${APP}-${(0, import_change_case.paramCase)(name)}`;
 };
 var getSearchName = getLocalResourceName;
 var getStoreName = getLocalResourceName;
-var getQueueName = getLocalResourceName;
-var getTopicName = getGlobalResourceName;
 var getSecretName = (name) => {
   return `/.awsless/${APP}/${name}`;
 };
@@ -86,14 +86,26 @@ var createProxy = (cb) => {
 var getFunctionName = (stack, name) => {
   return getLocalResourceName(name, stack);
 };
-var Function = createProxy((stack) => {
-  return createProxy((name) => {
-    return (event, options = {}) => {
-      return (0, import_lambda.invoke)({
-        ...options,
-        name: getFunctionName(stack, name),
-        payload: event
-      });
+var Function = createProxy((stackName) => {
+  return createProxy((funcName) => {
+    const name = getFunctionName(stackName, funcName);
+    return {
+      name,
+      invoke(payload, options = {}) {
+        return (0, import_lambda.invoke)({
+          ...options,
+          name,
+          payload
+        });
+      },
+      async(payload, options = {}) {
+        return (0, import_lambda.invoke)({
+          ...options,
+          name,
+          payload,
+          type: "Event"
+        });
+      }
     };
   });
 });
@@ -102,7 +114,33 @@ var Function = createProxy((stack) => {
 var getTableName = getLocalResourceName;
 var Table = createProxy((stack) => {
   return createProxy((name) => {
-    return getTableName(name, stack);
+    return {
+      name: getTableName(name, stack)
+    };
+  });
+});
+
+// src/node/topic.ts
+var getTopicName = getGlobalResourceName;
+var Topic = createProxy((topic) => {
+  const name = getTopicName(topic);
+  return {
+    name
+    // publish(payload:unknown) {
+    // }
+  };
+});
+
+// src/node/queue.ts
+var getQueueName = getLocalResourceName;
+var Queue = createProxy((stack) => {
+  return createProxy((queue) => {
+    const name = getQueueName(queue, stack);
+    return {
+      name
+      // sendMessage(payload:unknown) {
+      // }
+    };
   });
 });
 
@@ -116,7 +154,9 @@ var defineAppConfig = (config) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Function,
+  Queue,
   Table,
+  Topic,
   defineAppConfig,
   definePlugin,
   defineStackConfig,