@akanjs/cli 3.0.0-beta.9 → 3.0.0

package/index-4npz05nm.js

@@ -0,0 +1,187 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-vpj42xwt.js";
+import {
+  ModuleExecutor
+} from "./index-3w94e7n3.js";
+import {
+  sourceFile,
+  moduleSourcePaths,
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  bilingualLabelForField,
+  bilingualDescriptionForField
+} from "./index-y3mphr1m.js";
+import {
+  PageScript
+} from "./index-mbxbhay5.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 };

package/{index-q0y2jq9j.js → index-52w0fvh8.js}

@@ -1,9 +1,12 @@
 // @bun
 // pkgs/@akanjs/devkit/fileSys.ts
 import { lstat, rename, rm, stat } from "fs/promises";
+import nodePath from "path";
+import { fileURLToPath } from "url";
 import { Logger } from "akanjs/common";
+var getDirname2 = (url) => nodePath.dirname(fileURLToPath(url));
 
-class FileSys {
+class FileSys2 {
   static logger = new Logger("FileSys");
   static async fileExists(path) {
     return await Bun.file(path).exists();
@@ -24,7 +27,7 @@ class FileSys {
     try {
       return await Bun.file(path).json();
     } catch (error) {
-      FileSys.logger.error(`Failed to read JSON file: ${path}`);
+      FileSys2.logger.error(`Failed to read JSON file: ${path}`);
       throw error;
     }
   }
@@ -38,7 +41,7 @@ class FileSys {
     const temp = `${filePath}.${process.pid}.${Date.now().toString(36)}.tmp`;
     try {
       await Bun.write(temp, content);
-      await rename(temp, filePath);
+      await FileSys2.replace(temp, filePath);
     } catch (error) {
       await rm(temp, { force: true }).catch(() => {
         return;
@@ -46,10 +49,24 @@ class FileSys {
       throw error;
     }
   }
+  static #replaceAttempts = 100;
+  static async replace(temp, target) {
+    for (let attempt = 1;; attempt++) {
+      try {
+        return await rename(temp, target);
+      } catch (error) {
+        const code = error.code;
+        const busy = process.platform === "win32" && (code === "EPERM" || code === "EACCES" || code === "EBUSY");
+        if (!busy || attempt >= FileSys2.#replaceAttempts)
+          throw error;
+        await Bun.sleep(Math.min(10 * attempt, 50));
+      }
+    }
+  }
   static async writeJson(path, content) {
     return await Bun.file(path).write(`${JSON.stringify(content, null, 2)}
 `);
   }
 }
 
-export { FileSys };
+export { getDirname2, FileSys2 };