@akanjs/cli 0.9.60-canary.1 → 0.9.60-canary.12

package/cjs/index.js

@@ -1750,7 +1750,8 @@ ${errorMessages}`);
     const diagnostics = [
       ...program2.getSemanticDiagnostics(),
       ...program2.getSyntacticDiagnostics(),
-      ...program2.getDeclarationDiagnostics()
+      // Only check declaration diagnostics when declaration emit is enabled
+      ...this.config.options.declaration ? program2.getDeclarationDiagnostics() : []
     ];
     const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts3.DiagnosticCategory.Error);
     const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts3.DiagnosticCategory.Warning);
@@ -4047,7 +4048,11 @@ var LibraryRunner = class {
     lib.workspace.unsetTsPaths("lib", lib.name);
   }
   async installLibrary(workspace, libName) {
-    await workspace.exec(`git subtree add --prefix=libs/${libName} git@github.com:akan-team/${libName}.git main`);
+    workspace.mkdir("node_modules/.akan");
+    if (workspace.exists("node_modules/.akan/akanjs"))
+      await workspace.removeDir("node_modules/.akan/akanjs");
+    await workspace.exec(`cd node_modules/.akan && git clone git@github.com:akan-team/akanjs.git`);
+    await workspace.cp(`node_modules/.akan/akanjs/libs/${libName}`, `libs/${libName}`);
     await workspace.cp(`libs/${libName}/env/env.server.example.ts`, `libs/${libName}/env/env.server.testing.ts`);
     workspace.setTsPaths("lib", libName);
     await workspace.commit(`Add ${libName} library`);
@@ -4079,16 +4084,6 @@ var LibraryRunner = class {
     await lib.workspace.spawn("pnpm", ["install", "--reporter=silent"]);
     await lib.workspace.commit(`Merge ${lib.name} library dependencies`);
   }
-  async pushLibrary(lib, branch) {
-    await lib.workspace.exec(
-      `git subtree push --prefix=libs/${lib.name} git@github.com:akan-team/${lib.name}.git ${branch}`
-    );
-  }
-  async pullLibrary(lib, branch) {
-    await lib.workspace.exec(
-      `git subtree pull --prefix=libs/${lib.name} git@github.com:akan-team/${lib.name}.git ${branch}`
-    );
-  }
   #getEnv(lib, env = {}) {
     const rootEnv = import_dotenv2.default.parse(lib.workspace.readFile(".env"));
     return {
@@ -4144,19 +4139,6 @@ var LibraryScript = class {
     await this.#runner.mergeLibraryDependencies(lib);
     mergeSpinner.succeed(`${libName} library (libs/${libName}) dependencies merged to root package.json`);
   }
-  async pushLibrary(lib, branch) {
-    const pushSpinner = lib.spinning("Pushing library...");
-    await this.#runner.pushLibrary(lib, branch);
-    pushSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) pushed to ${branch} branch`);
-  }
-  async pullLibrary(lib, branch) {
-    const pullSpinner = lib.spinning("Pulling library...");
-    await this.#runner.pullLibrary(lib, branch);
-    pullSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) pulled from ${branch} branch`);
-    const mergeSpinner = lib.spinning("Merging library dependencies...");
-    await this.#runner.mergeLibraryDependencies(lib);
-    mergeSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) dependencies merged to root package.json`);
-  }
   async testLibrary(lib) {
     const spinner = lib.spinning("Testing library...");
     await this.#runner.testLibrary(lib);
@@ -6049,12 +6031,6 @@ var LibraryCommand = class {
   async installLibrary(libName, workspace) {
     await this.libraryScript.installLibrary(workspace, libName);
   }
-  async pushLibrary(lib, branch) {
-    await this.libraryScript.pushLibrary(lib, branch);
-  }
-  async pullLibrary(lib, branch) {
-    await this.libraryScript.pullLibrary(lib, branch);
-  }
 };
 __decorateClass([
   Target.Public(),
@@ -6074,16 +6050,6 @@ __decorateClass([
   __decorateParam(0, Argument("libName", { desc: "name of library", nullable: true })),
   __decorateParam(1, Workspace())
 ], LibraryCommand.prototype, "installLibrary", 1);
-__decorateClass([
-  Target.Public({ devOnly: true }),
-  __decorateParam(0, Lib()),
-  __decorateParam(1, Option("branch", { desc: "branch to push", default: "main" }))
-], LibraryCommand.prototype, "pushLibrary", 1);
-__decorateClass([
-  Target.Public(),
-  __decorateParam(0, Lib()),
-  __decorateParam(1, Option("branch", { desc: "branch to pull", default: "main" }))
-], LibraryCommand.prototype, "pullLibrary", 1);
 LibraryCommand = __decorateClass([
   Commands()
 ], LibraryCommand);
@@ -6452,12 +6418,12 @@ var ModuleRunner = class {
       },
       signal: {
         filename: `${module2.name}.signal.ts`,
-        content: module2.readFile(`${module2.name}.signal.spec.ts`)
-      },
-      test: {
-        filename: `${module2.name}.test.ts`,
-        content: module2.readFile(`${module2.name}.signal.test.ts`)
+        content: module2.readFile(`${module2.name}.signal.ts`)
       },
+      // test: {
+      //   filename: `${module.name}.test.ts`,
+      //   content: module.readFile(`${module.name}.signal.test.ts`),
+      // },
       unit: {
         filename: `${module2.name}.Unit.tsx`,
         content: module2.readFile(`${module2.name}.Unit.tsx`)
@@ -7330,8 +7296,8 @@ var ScalarPrompt = class extends Prompter {
   }
   async requestCreateConstant() {
     const constantFiles = await this.sys.getConstantFilesWithLibs();
-    const description = await (0, import_prompts10.input)({ message: "description of scalar scalar" });
-    const schemaDescription = await (0, import_prompts10.input)({ message: "schema description of scalar scalar" });
+    const description = await (0, import_prompts10.input)({ message: "description of scalar" });
+    const schemaDescription = await (0, import_prompts10.input)({ message: "schema description of scalar" });
     await this.sys.applyTemplate({
       basePath: "./lib/__scalar",
       template: "__scalar",
@@ -7442,6 +7408,14 @@ ${boilerplate}
 
 // pkgs/@akanjs/cli/src/scalar/scalar.runner.ts
 var ScalarRunner = class {
+  async applyScalarTemplate(sys3, scalarName) {
+    await sys3.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: scalarName, models: (0, import_pluralize3.default)(scalarName), sysName: sys3.name },
+      overwrite: false
+    });
+  }
   async createScalarConstant(sys3, scalarName) {
     const isContinued = sys3.exists(`lib/__scalar/${scalarName}/${scalarName}.constant.ts`);
     const prompt = new ScalarPrompt(sys3, scalarName);
@@ -7450,12 +7424,7 @@ var ScalarRunner = class {
     const writes = await session.writeTypescripts(request, sys3, { validate });
     const scalarNames = writes.map(({ filePath }) => filePath.split("/").at(-2)).filter((name) => !!name);
     for (const name of scalarNames)
-      await sys3.applyTemplate({
-        basePath: "./lib/__scalar",
-        template: "__scalar",
-        dict: { model: name, models: (0, import_pluralize3.default)(name), sysName: sys3.name },
-        overwrite: false
-      });
+      await this.applyScalarTemplate(sys3, name);
     return { session, scalarNames, writes, prompt };
   }
   async updateScalarDictionaries(sys3, scalarNames, { session }) {
@@ -7475,6 +7444,9 @@ var ScalarRunner = class {
 var ScalarScript = class {
   #runner = new ScalarRunner();
   async createScalar(sys3, scalarName) {
+    await this.#runner.applyScalarTemplate(sys3, scalarName);
+  }
+  async createScalarWithAi(sys3, scalarName) {
     const { session, scalarNames } = await this.#runner.createScalarConstant(sys3, scalarName);
     await this.#runner.updateScalarDictionaries(sys3, scalarNames, { session });
   }
@@ -7486,22 +7458,25 @@ var ScalarScript = class {
 // pkgs/@akanjs/cli/src/scalar/scalar.command.ts
 var ScalarCommand = class {
   scalarScript = new ScalarScript();
-  async createScalar(sys3, scalarName) {
+  async createScalar(scalarName, ai, sys3) {
+    if (ai)
+      await this.scalarScript.createScalarWithAi(sys3, lowerlize(scalarName.replace(/ /g, "")));
     await this.scalarScript.createScalar(sys3, lowerlize(scalarName.replace(/ /g, "")));
   }
-  async removeScalar(sys3, scalarName) {
+  async removeScalar(scalarName, sys3) {
     await this.scalarScript.removeScalar(sys3, scalarName);
   }
 };
 __decorateClass([
   Target.Public(),
-  __decorateParam(0, Sys()),
-  __decorateParam(1, Argument("scalarName", { desc: "name of scalar scalar" }))
+  __decorateParam(0, Argument("scalarName", { desc: "name of scalar" })),
+  __decorateParam(1, Option("ai", { type: "boolean", default: false, desc: "use ai to create scalar" })),
+  __decorateParam(2, Sys())
 ], ScalarCommand.prototype, "createScalar", 1);
 __decorateClass([
   Target.Public(),
-  __decorateParam(0, Sys()),
-  __decorateParam(1, Argument("scalarName", { desc: "name of scalar scalar" }))
+  __decorateParam(0, Argument("scalarName", { desc: "name of scalar" })),
+  __decorateParam(1, Sys())
 ], ScalarCommand.prototype, "removeScalar", 1);
 ScalarCommand = __decorateClass([
   Commands()

package/cjs/src/guidelines/scalarConstant/scalarConstant.generate.json

@@ -14,8 +14,8 @@
     },
     {
       "type": "source",
-      "description": "scalar metadata implementation",
-      "path": "pkgs/@akanjs/constant/src/scalar.ts"
+      "description": "via() function and scalar implementation",
+      "path": "pkgs/@akanjs/constant/src/baseGql.ts"
     },
     {
       "type": "source",
@@ -72,30 +72,34 @@
       "Purpose of scalar constants in Akan.js",
       "File structure and location conventions",
       "Naming standards for directories, files, classes and enums",
-      "Required imports and framework types",
-      "Model definition with @Model.Scalar decorator",
-      "Field definitions with @Field.Prop and other decorators",
-      "Field options reference table",
-      "Array fields implementation",
-      "Map fields implementation",
-      "Enum implementation with enumOf",
+      "Required imports from @akanjs/constant and @akanjs/base",
+      "Basic syntax with via() function",
+      "Field definitions with field() helper function",
+      "Field options reference table (default, min, max, minlength, maxlength, validate, example)",
+      "Available field types (String, Int, Float, Boolean, Date, ID)",
+      "Array fields using bracket notation [Type]",
+      "Optional fields using .optional() chain method",
+      "Enum definition with enumOf(name, values) class pattern",
+      "Instance methods in scalar classes",
       "Static methods in scalar classes",
-      "Validation rules and checklists",
       "Common mistakes and fixes",
+      "Implementation checklist",
       "Full examples of scalar.constant.ts files"
     ],
     "rules": [
-      "One scalar.constant.ts should contain only one @Model.Scalar class. If you need more than one scalar model, make another scalar.constant.ts file.",
-      "The directory and filename convention is camelCase, such as `geoLocation/geoLocation.constant.ts`",
-      "The class name should be PascalCase, matching the camelCase directory name (e.g., GeoLocation for geoLocation)",
-      "The @Model.Scalar parameter MUST match the class name exactly",
-      "The values of enum strings must be camelCase (not uppercase)",
-      "Do not forget to import required imports like enumOf, Float, type Dayjs, etc.",
-      "Do not add options that don't exist in Field.Prop decorator. Carefully check that each option exists.",
-      "Always use Dayjs type for Date fields, not JavaScript's native Date",
-      "For nullable fields, add both the { nullable: true } option and the TypeScript union type (Type | null)",
+      "One scalar.constant.ts should contain only one scalar class extending via(). If you need more than one scalar model, make another scalar.constant.ts file.",
+      "The directory and filename convention is camelCase, such as `encourageInfo/encourageInfo.constant.ts`",
+      "The class name should be PascalCase, matching the camelCase directory name (e.g., EncourageInfo for encourageInfo)",
+      "Use `extends via((field) => ({...}))` pattern to define scalar classes, not decorators",
+      "Import `via` from `@akanjs/constant` and `enumOf`, `ID`, `Int`, `Float`, `dayjs` from `@akanjs/base`",
+      "The values of enum strings must be camelCase (e.g., 'waitPay', not 'WAIT_PAY')",
+      "Define enums using class pattern: `export class EnumName extends enumOf('enumName', [...] as const) {}`",
+      "The first argument of enumOf() is the enum name string used in dictionary/GraphQL",
+      "Use .optional() chain method for nullable fields, not { nullable: true } option",
       "Use bracket notation for arrays ([Type]) rather than generics (Array<Type>)",
-      "Always export both const and type for enums created with enumOf"
+      "Use factory functions for dynamic defaults: { default: () => dayjs() }, not { default: dayjs() }",
+      "Always export both the scalar class and enum classes",
+      "Add 'as const' to enum value arrays for better TypeScript type inference"
     ]
   },
   "page": "/[lang]/akanjs/(docs)/docs/scalar/constant/page.tsx"