@akanjs/cli 3.0.0-beta.8 → 3.0.0

package/{index-d43r08tf.js → index-kqabytj7.js}

@@ -1,23 +1,25 @@
 // @bun
 import {
   script
-} from "./index-0g7r8xz3.js";
+} from "./index-vpj42xwt.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-3w94e7n3.js";
 import {
+  workflowStatus,
   compactDiagnostics,
-  createPrimitiveWriteReport,
   sourceFile,
   moduleComponentName,
   moduleSourcePaths,
   generatedFilesForSync,
   validationCommandsForTarget,
   nextActionsForTarget,
-  lowerlize,
+  createPrimitiveWriteReport,
   normalizeFieldType,
+  ensureNamedImport,
+  ensureBaseImport,
   ensureBaseTypeImport,
   coerceFieldDefault,
   fieldExpression,
@@ -39,13 +41,13 @@ import {
   hasSignalFactoryEntry,
   insertSignalFactoryEntry,
   addFieldUiPolicyForType
-} from "./index-gyd220p2.js";
+} from "./index-y3mphr1m.js";
 import {
   ModuleScript
-} from "./index-5ystnsd5.js";
+} from "./index-4npz05nm.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
-import { capitalize } from "akanjs/common";
+import { capitalize, lowerlize } from "akanjs/common";
 class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async resolveSys(workspace, target) {
     if (!target)
@@ -59,28 +61,11 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   }
   async createUi(workspace, input) {
     const sys = await this.resolveSys(workspace, input.app);
-    if (!sys || !input.module) {
-      return createPrimitiveWriteReport({
-        command: "create-ui",
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics: compactDiagnostics([
-          !sys && {
-            severity: "error",
-            code: "primitive-target-missing",
-            message: "Target app or library was not found."
-          },
-          !input.module && {
-            severity: "error",
-            code: "primitive-input-missing",
-            message: "Module is required.",
-            input: "module"
-          }
-        ]),
-        nextActions: []
-      });
-    }
+    if (!sys || !input.module)
+      return PrimitiveScript.#refuse("create-ui", compactDiagnostics([
+        !sys && PrimitiveScript.#targetMissing(),
+        !input.module && PrimitiveScript.#inputMissing("module")
+      ]));
     const mod = ModuleExecutor.from(sys, input.module);
     if (input.surface === "view")
       return await this.moduleScript.createView(mod);
@@ -96,30 +81,16 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     return await this.addFieldToSources(workspace, { ...input, type: `${capitalize(input.field ?? "")}` }, { enumValues: values });
   }
   async addFieldToSources(workspace, input, { enumValues }) {
+    const command = enumValues ? "add-enum-field" : "add-field";
     const sys = await this.resolveSys(workspace, input.app);
     const ambiguousNumberTypes = new Set(["number", "numeric"]);
     const normalizedType = input.type ? normalizeFieldType(input.type) : null;
     const diagnostics = compactDiagnostics([
-      !sys && { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." },
-      !input.module && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Module is required.",
-        input: "module"
-      },
-      !input.field && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Field is required.",
-        input: "field"
-      },
-      !input.type && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Type is required.",
-        input: "type"
-      },
-      enumValues && enumValues.length === 0 ? { severity: "error", code: "primitive-input-missing", message: "Enum values are required.", input: "values" } : null,
+      !sys && PrimitiveScript.#targetMissing(),
+      !input.module && PrimitiveScript.#inputMissing("module"),
+      !input.field && PrimitiveScript.#inputMissing("field"),
+      !input.type && PrimitiveScript.#inputMissing("type"),
+      enumValues?.length === 0 && PrimitiveScript.#inputMissing("values", "Enum values are required."),
       input.type && ambiguousNumberTypes.has(input.type.toLowerCase()) ? {
         severity: "error",
         code: "primitive-field-type-unsupported",
@@ -133,16 +104,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         input: "type"
       } : null
     ]);
-    if (!sys || !input.module || !input.field || !input.type || diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: enumValues ? "add-enum-field" : "add-field",
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics,
-        nextActions: []
-      });
-    }
+    if (!sys || !input.module || !input.field || !input.type || workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#refuse(command, diagnostics);
     const moduleClassName = moduleComponentName(input.module);
     const inputClassName = `${moduleClassName}Input`;
     const paths = moduleSourcePaths(input.module);
@@ -150,32 +113,13 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     const dictionaryPath = paths.dictionary;
     const templatePath = paths.template;
     const changedFiles = [];
-    const generatedFiles = generatedFilesForSync(sys);
     const [hasConstant, hasDictionary] = await Promise.all([sys.exists(constantPath), sys.exists(dictionaryPath)]);
-    if (!hasConstant) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Constant source file was not found: ${constantPath}.`
-      });
-    }
-    if (!hasDictionary) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Dictionary source file was not found: ${dictionaryPath}.`
-      });
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: enumValues ? "add-enum-field" : "add-field",
-        changedFiles,
-        generatedFiles,
-        validationCommands: validationCommandsForTarget(sys.name),
-        diagnostics,
-        nextActions: nextActionsForTarget(sys.name)
-      });
-    }
+    if (!hasConstant)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Constant", constantPath));
+    if (!hasDictionary)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Dictionary", dictionaryPath));
+    if (workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#report(command, sys, changedFiles, diagnostics);
     let constantContent = await sys.readFile(constantPath);
     let dictionaryContent = await sys.readFile(dictionaryPath);
     const fieldBuilderName = viaBuilderParameterName(constantContent, inputClassName) ?? "field";
@@ -210,6 +154,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       if (defaultCoercion.diagnostic)
         diagnostics.push(defaultCoercion.diagnostic);
       constantContent = ensureBaseTypeImport(constantContent, input.type);
+      if (input.type === "Date" && defaultCoercion.expression)
+        constantContent = ensureBaseImport(constantContent, "dayjs");
     }
     if (enumValues) {
       const defaultCoercion = coerceFieldDefault("enum", input.defaultValue, { enumValues });
@@ -311,7 +257,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         }
       }
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextConstantContentWithLight && nextDictionaryContent) {
+    if (workflowStatus(diagnostics) === "passed" && nextConstantContentWithLight && nextDictionaryContent) {
       await sys.writeFile(constantPath, nextConstantContentWithLight);
       await sys.writeFile(dictionaryPath, nextDictionaryContent);
       changedFiles.push(sourceFile(sys, constantPath, "modify", "Field source shape was updated."), sourceFile(sys, dictionaryPath, "modify", "Field dictionary labels were updated."));
@@ -320,14 +266,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         changedFiles.push(sourceFile(sys, templatePath, "modify", "Template field surface was updated."));
       }
     }
-    return createPrimitiveWriteReport({
-      command: enumValues ? "add-enum-field" : "add-field",
-      changedFiles,
-      generatedFiles,
-      validationCommands: validationCommandsForTarget(sys.name),
-      diagnostics,
-      nextActions: nextActionsForTarget(sys.name)
-    });
+    return PrimitiveScript.#report(command, sys, changedFiles, diagnostics);
   }
   async addMutation(workspace, input) {
     const moduleClassName = input.module ? moduleComponentName(input.module) : "";
@@ -353,7 +292,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       signal: name ? {
         className: `${moduleClassName}Endpoint`,
         entryLine: [
-          `${name}: mutation(Boolean)`,
+          `${name}: mutation(Boolean, { guards: [None] })`,
           `    .exec(async function () {`,
           `      return await this.${serviceRef}Service.${name}();`,
           `    }),`
@@ -388,7 +327,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       signal: name && queryName ? {
         className: `${moduleClassName}Slice`,
         entryLine: [
-          `${name}: init()`,
+          `${name}: init({ guards: [None] })`,
           `    .exec(function () {`,
           `      return this.${serviceRef}Service.${queryName}();`,
           `    }),`
@@ -401,60 +340,21 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async#writeServiceSignalEntry(workspace, spec) {
     const sys = await this.resolveSys(workspace, spec.app);
     const diagnostics = compactDiagnostics([
-      !sys && { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." },
-      !spec.module && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Module is required.",
-        input: "module"
-      },
-      !spec.entryName && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: `${capitalize(spec.requiredInput)} name is required.`,
-        input: spec.requiredInput
-      }
+      !sys && PrimitiveScript.#targetMissing(),
+      !spec.module && PrimitiveScript.#inputMissing("module"),
+      !spec.entryName && PrimitiveScript.#inputMissing(spec.requiredInput, `${capitalize(spec.requiredInput)} name is required.`)
     ]);
-    if (!sys || !spec.module || !spec.entryName || !spec.serviceMethod || !spec.signal) {
-      return createPrimitiveWriteReport({
-        command: spec.command,
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics,
-        nextActions: []
-      });
-    }
-    const paths = moduleSourcePaths(spec.module);
-    const servicePath = paths.service;
-    const signalPath = paths.signal;
+    if (!sys || !spec.module || !spec.entryName || !spec.serviceMethod || !spec.signal)
+      return PrimitiveScript.#refuse(spec.command, diagnostics);
+    const { service: servicePath, signal: signalPath } = moduleSourcePaths(spec.module);
     const changedFiles = [];
-    const generatedFiles = generatedFilesForSync(sys);
     const [hasServiceFile, hasSignalFile] = await Promise.all([sys.exists(servicePath), sys.exists(signalPath)]);
-    if (!hasServiceFile) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Service source file was not found: ${servicePath}.`
-      });
-    }
-    if (!hasSignalFile) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Signal source file was not found: ${signalPath}.`
-      });
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: spec.command,
-        changedFiles,
-        generatedFiles,
-        validationCommands: validationCommandsForTarget(sys.name),
-        diagnostics,
-        nextActions: nextActionsForTarget(sys.name)
-      });
-    }
+    if (!hasServiceFile)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Service", servicePath));
+    if (!hasSignalFile)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Signal", signalPath));
+    if (workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#report(spec.command, sys, changedFiles, diagnostics);
     const serviceClassName = `${moduleComponentName(spec.module)}Service`;
     const serviceContent = await sys.readFile(servicePath);
     const signalContent = await sys.readFile(signalPath);
@@ -476,7 +376,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       });
     }
     const nextServiceContent = serviceMethodExists ? serviceContent : insertClassMethod(serviceContent, serviceClassName, spec.serviceMethod.block);
-    const nextSignalContent = insertSignalFactoryEntry(signalContent, spec.signal.className, spec.entryName, spec.signal.entryLine, spec.signal.param);
+    const insertedSignalContent = insertSignalFactoryEntry(signalContent, spec.signal.className, spec.entryName, spec.signal.entryLine, spec.signal.param);
+    const nextSignalContent = insertedSignalContent ? ensureNamedImport(insertedSignalContent, "akanjs/signal", "None") : insertedSignalContent;
     if (!nextServiceContent) {
       diagnostics.push({
         severity: "error",
@@ -515,20 +416,46 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         message: `Edited ${signalPath} did not contain entry "${spec.entryName}" in ${spec.signal.className}.`
       });
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextServiceContent && nextSignalContent) {
+    if (workflowStatus(diagnostics) === "passed" && nextServiceContent && nextSignalContent) {
       await sys.writeFile(servicePath, nextServiceContent);
       await sys.writeFile(signalPath, nextSignalContent);
       changedFiles.push(sourceFile(sys, servicePath, "modify", `Service ${spec.entryKind} was added.`), sourceFile(sys, signalPath, "modify", `Signal ${spec.entryKind} was added.`));
     }
+    return PrimitiveScript.#report(spec.command, sys, changedFiles, diagnostics);
+  }
+  static #refuse(command, diagnostics) {
+    return createPrimitiveWriteReport({
+      command,
+      changedFiles: [],
+      generatedFiles: [],
+      validationCommands: [],
+      diagnostics,
+      nextActions: []
+    });
+  }
+  static #report(command, sys, changedFiles, diagnostics) {
     return createPrimitiveWriteReport({
-      command: spec.command,
+      command,
       changedFiles,
-      generatedFiles,
+      generatedFiles: generatedFilesForSync(sys),
       validationCommands: validationCommandsForTarget(sys.name),
       diagnostics,
       nextActions: nextActionsForTarget(sys.name)
     });
   }
+  static #targetMissing() {
+    return { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." };
+  }
+  static #inputMissing(input, message = `${capitalize(input)} is required.`) {
+    return { severity: "error", code: "primitive-input-missing", message, input };
+  }
+  static #sourceMissing(kind, path) {
+    return {
+      severity: "error",
+      code: "primitive-source-missing",
+      message: `${kind} source file was not found: ${path}.`
+    };
+  }
 }
 
 export { PrimitiveScript };

package/{index-vyvre9en.js → index-mbxbhay5.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-0g7r8xz3.js";
+} from "./index-vpj42xwt.js";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {
@@ -10,7 +10,11 @@ class PageRunner extends runner("page") {
     await app.applyTemplate({
       basePath: basePath ?? `page/(${app.name})/(public)/${module.name}`,
       template: single ? "crudSinglePage" : "crudPages",
-      dict: { model: module.name, appName: module.sys.name }
+      dict: {
+        model: module.name,
+        appName: module.sys.name,
+        clientPath: `@${module.sys.type}s/${module.sys.name}/client`
+      }
     });
   }
 }

package/{index-vxtad5bd.js → index-mgxpx3f2.js}

@@ -2,23 +2,21 @@
 import {
   runner,
   script
-} from "./index-0g7r8xz3.js";
+} from "./index-vpj42xwt.js";
 import {
   LibExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-3w94e7n3.js";
 import {
   LibSource,
   formatLibStatuses
-} from "./index-3d9y066c.js";
+} from "./index-bjwxs904.js";
 
 // pkgs/@akanjs/cli/library/library.script.ts
 import { Logger } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/semver.ts
 var stripRangeOperator = (version) => version.replace(/^[\s^~>=<v]+/, "").trim();
-var parseVersion = (version) => {
-  return version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
-};
+var parseVersion = (version) => version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
 var compareNumeric = (a, b) => {
   const left = parseVersion(a);
   const right = parseVersion(b);
@@ -44,8 +42,7 @@ class LibraryRunner extends runner("library") {
   async createLibrary(libName, workspace) {
     await workspace.mkdir(`libs/${libName}`);
     await workspace.applyTemplate({ basePath: `libs/${libName}`, template: "libRoot", dict: { libName } });
-    const lib = LibExecutor.from(workspace, libName);
-    return lib;
+    return LibExecutor.from(workspace, libName);
   }
   async removeLibrary(lib) {
     await lib.workspace.removeDir(`libs/${lib.name}`);

package/index-p6pbz9n5.js

@@ -0,0 +1,25 @@
+// @bun
+// pkgs/@akanjs/cli/clipboard.ts
+var clipboardCommands = () => {
+  if (process.platform === "darwin")
+    return [["pbcopy"]];
+  if (process.platform === "win32")
+    return [["clip"]];
+  return [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+};
+var writeClipboard = async (text) => {
+  for (const command of clipboardCommands()) {
+    try {
+      const proc = Bun.spawn(command, {
+        stdin: new TextEncoder().encode(text),
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      if (await proc.exited === 0)
+        return true;
+    } catch {}
+  }
+  return false;
+};
+
+export { writeClipboard };