@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.21

package/index-smme4r47.js

@@ -0,0 +1,49 @@
+// @bun
+import {
+  GlobalConfig,
+  CloudApi
+} from "./index-22d57v4c.js";
+
+// pkgs/@akanjs/cli/tunnel/TunnelShare.ts
+import { TunnelAgent } from "akanjs/server/tunnel";
+
+class TunnelShare2 {
+  #api;
+  #agent;
+  grant;
+  #closed = false;
+  constructor(api, agent, grant) {
+    this.#api = api;
+    this.#agent = agent;
+    this.grant = grant;
+  }
+  static async open(app, { workspace, host, port, ttlMinutes, onLost }) {
+    const api = await CloudApi.fromHost(workspace, host ?? GlobalConfig.akanCloudHost);
+    const grant = await api.requestTunnel({ name: app.name, ...ttlMinutes ? { ttlMinutes } : {} });
+    const origin = `http://localhost:${port ?? await app.getDevPort()}`;
+    const agent = new TunnelAgent({
+      gatewayUrl: grant.gatewayUrl,
+      token: grant.token,
+      hostnames: [grant.hostname],
+      origin,
+      name: app.name,
+      ...onLost ? { onLost } : {}
+    });
+    await agent.start();
+    return new TunnelShare2(api, agent, grant);
+  }
+  get url() {
+    return this.grant.url;
+  }
+  async close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    await this.#agent.stop("cli exited");
+    try {
+      await this.#api.revokeTunnel(this.grant.code);
+    } catch {}
+  }
+}
+
+export { TunnelShare2 };

package/index-tgjy8xf3.js

@@ -0,0 +1,187 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-rmcw8yc8.js";
+import {
+  ModuleExecutor
+} from "./index-ga6hygxr.js";
+import {
+  sourceFile,
+  moduleSourcePaths,
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  bilingualLabelForField,
+  bilingualDescriptionForField
+} from "./index-yy4s1j72.js";
+import {
+  PageScript
+} from "./index-rnt66vym.js";
+import {
+  pluralizeName
+} from "./index-nz8prx9g.js";
+
+// pkgs/@akanjs/cli/module/module.script.ts
+import { capitalize as capitalize2 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/module/module.runner.ts
+import { capitalize } from "akanjs/common";
+var purposeByModule = {
+  budget: "Budget represents planned or actual money allocated inside the app.",
+  project: "Project represents a project workspace or business initiative managed by the app.",
+  task: "Task represents work items that move through the app workflow."
+};
+var moduleAbstractContent = (moduleName, sharedGuards) => {
+  const title = capitalize(moduleName);
+  const noun = bilingualLabelForField(moduleName).en.toLowerCase();
+  const purpose = purposeByModule[moduleName] ?? `${title} represents ${noun} records managed by the app.`;
+  const writeRule = sharedGuards ? `Anyone may read a ${noun}; only an admin creates, updates or removes one.` : `Anyone may read a ${noun}; nobody creates, updates or removes one until the slice names a guard.`;
+  return `# ${moduleName} Abstract
+${purpose}
+
+## Rules
+- ${writeRule}
+- Removal is soft: a removed ${noun} keeps its row with \`removedAt\` set.
+`;
+};
+var moduleFileKeys = [
+  "abstract",
+  "constant",
+  "dictionary",
+  "service",
+  "store",
+  "signal",
+  "unit",
+  "view",
+  "template",
+  "zone",
+  "util"
+];
+
+class ModuleRunner extends runner("module") {
+  async createService(module) {
+    const serviceName = module.name.replace(/^_+/, "");
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "service",
+      dict: { model: serviceName, sysName: module.sys.name }
+    });
+    return await this.#readFiles(module, {
+      abstract: `${serviceName}.abstract.md`,
+      dictionary: `${serviceName}.dictionary.ts`,
+      service: `${serviceName}.service.ts`,
+      signal: `${serviceName}.signal.ts`,
+      store: `${serviceName}.store.ts`
+    });
+  }
+  async#readFiles(module, filenames) {
+    const files = await Promise.all(Object.entries(filenames).map(async ([key, filename]) => [
+      key,
+      { filename, content: await module.readFile(filename) }
+    ]));
+    return Object.fromEntries(files);
+  }
+  async removeModule(module) {
+    await module.sys.removeDir(`lib/${module.name}`);
+  }
+  async#hasSharedGuards(module) {
+    const { sys } = module;
+    if (sys.type === "lib" && sys.name === "shared")
+      return true;
+    if (!await sys.exists("lib/srv.ts"))
+      return false;
+    return (await sys.readFile("lib/srv.ts")).includes('"@libs/shared/lib/srv"');
+  }
+  async createComponentTemplate(module, type) {
+    await module.sys.applyTemplate({
+      basePath: `./lib/${module.name}`,
+      template: `module/__Model__.${capitalize(type)}.tsx`,
+      dict: { model: module.name, sysName: module.sys.name, sysType: module.sys.type }
+    });
+    return {
+      component: {
+        filename: `${capitalize(module.name)}.${capitalize(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize(module.name)}.${capitalize(type)}.tsx`)
+      }
+    };
+  }
+  async createModuleTemplate(module) {
+    const names = pluralizeName(module.name);
+    const modelLabel = bilingualLabelForField(module.name);
+    const modelDescription = bilingualDescriptionForField(module.name);
+    const paths = moduleSourcePaths(module.name);
+    const filenames = Object.fromEntries(moduleFileKeys.map((key) => [key, paths[key].replace(`lib/${module.name}/`, "")]));
+    const sharedGuards = await this.#hasSharedGuards(module);
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "module",
+      options: { sharedGuards },
+      dict: {
+        model: module.name,
+        models: names,
+        sysName: module.sys.name,
+        sysType: module.sys.type,
+        modelLabelEn: modelLabel.en,
+        modelLabelKo: modelLabel.ko,
+        modelDescEn: modelDescription.en,
+        modelDescKo: modelDescription.ko
+      }
+    });
+    await module.writeFile(filenames.abstract, moduleAbstractContent(module.name, sharedGuards));
+    return await this.#readFiles(module, filenames);
+  }
+}
+
+// pkgs/@akanjs/cli/module/module.script.ts
+var moduleChangedFiles = (sys, moduleName, files) => Object.values(files).map((file) => sourceFile(sys, `lib/${moduleName}/${file.filename}`, "create", "Module source file was created."));
+
+class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
+  async createModuleTemplate(sys, name, { page = false } = {}) {
+    const mod = ModuleExecutor.from(sys, name);
+    const files = await this.moduleRunner.createModuleTemplate(mod);
+    if (page && sys.type === "app")
+      await this.pageScript.createCrudPage(mod, { app: sys, basePath: null, single: false });
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-module",
+      changedFiles: moduleChangedFiles(sys, name, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after module creation."),
+      target: sys.name
+    });
+  }
+  async removeModule(mod) {
+    await this.moduleRunner.removeModule(mod);
+  }
+  async createService(sys, name) {
+    const service = ModuleExecutor.from(sys, `_${name}`);
+    const files = await this.moduleRunner.createService(service);
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-service",
+      changedFiles: moduleChangedFiles(sys, `_${name}`, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after service creation."),
+      target: sys.name
+    });
+  }
+  async createTemplate(mod) {
+    return await this.#createComponent(mod, "template");
+  }
+  async createUnit(mod) {
+    return await this.#createComponent(mod, "unit");
+  }
+  async createView(mod) {
+    return await this.#createComponent(mod, "view");
+  }
+  async#createComponent(mod, type) {
+    const { component } = await this.moduleRunner.createComponentTemplate(mod, type);
+    return createPassedPrimitiveReport({
+      command: `create-${type}`,
+      changedFiles: [
+        sourceFile(mod.sys, `lib/${mod.name}/${component.filename}`, "create", `${capitalize2(type)} UI source was created.`)
+      ],
+      target: mod.sys.name
+    });
+  }
+}
+
+export { ModuleScript };