@akanjs/cli 0.9.56 → 0.9.58-canary.0

package/cjs/src/templates/module/__model__.dictionary.js

@@ -24,64 +24,26 @@ __export(model_dictionary_exports, {
 module.exports = __toCommonJS(model_dictionary_exports);
 function getContent(scanInfo, dict) {
   return `
-import { baseTrans, getBaseSignalTrans, ModelDictionary, SignalDictionary } from "@akanjs/dictionary";
-
-import type { ${dict.Model}, ${dict.Model}Filter, ${dict.Model}Insight, ${dict.Model}Summary } from "./${dict.model}.constant";
-import type { ${dict.Model}Signal } from "./${dict.model}.signal";
-
-export const modelDictionary = {
-  ...baseTrans,
-  modelName: ["${dict.Model}", "${dict.Model}"],
-  modelDesc: [
-    "${dict.Model} description",
-    "${dict.Model} \uC124\uBA85",
-  ],
-
-  // * ==================== Model ==================== * //
-  field: ["Field", "\uD544\uB4DC"],
-  "desc-field": ["Field", "\uD544\uB4DC"],
-  // * ==================== Model ==================== * //
-
-  // * ==================== Insight ==================== * //
-  count: ["Count", "\uAC1C\uC218"],
-  "desc-count": ["${dict.Model} count in current query settting", "\uD604\uC7AC \uCFFC\uB9AC \uC124\uC815\uC5D0 \uB9DE\uB294 \uBC30\uB108 \uC218"],
-  // * ==================== Insight ==================== * //
-
-  // * ==================== Filter ==================== * //
-  "qry-inStatus": ["In Status", "\uC0C1\uD0DC"],
-  "qrydesc-inStatus": ["Filter by status", "\uC0C1\uD0DC\uBCC4 \uD544\uD130\uB9C1"],
-  "qarg-inStatus-status": ["Status", "\uC0C1\uD0DC"],
-  "qargdesc-inStatus-status": ["Filter by status", "\uC0C1\uD0DC\uBCC4 \uD544\uD130\uB9C1"],
-  // * ==================== Filter ==================== * //
-
-  // * ==================== Etc ==================== * //
-  "enum-status-active": ["Active", "\uD65C\uC131"],
-  "enumdesc-status-active": ["Active status", "\uD65C\uC131 \uC0C1\uD0DC"],
-  // * ==================== Etc ==================== * //
-} satisfies ModelDictionary<${dict.Model}, ${dict.Model}Insight, ${dict.Model}Filter>;
-
-export const signalDictionary = {
-  ...getBaseSignalTrans("${dict.model}" as const),
-  // * ==================== Endpoint ==================== * //
-  "api-${dict.model}ListInPublic": ["${dict.Model} List In Public", "\uACF5\uAC1C\uB41C ${dict.Model} \uB9AC\uC2A4\uD2B8"],
-  "apidesc-${dict.model}ListInPublic": ["Get a list of public ${dict.model}", "\uACF5\uAC1C\uB41C ${dict.Model}\uC758 \uB9AC\uC2A4\uD2B8\uB97C \uAC00\uC838\uC635\uB2C8\uB2E4"],
-  "arg-${dict.model}ListInPublic-statuses": ["Statuses", "\uC0C1\uD0DC"],
-  "argdesc-${dict.model}ListInPublic-statuses": ["Statuses to filter", "\uD544\uD130\uB9C1\uD560 \uC0C1\uD0DC"],
-  "arg-${dict.model}ListInPublic-skip": ["Skip", "\uAC74\uB108\uB6F0\uAE30"],
-  "argdesc-${dict.model}ListInPublic-skip": ["Number of items to skip", "\uAC74\uB108\uB6F8 \uC544\uC774\uD15C \uC218"],
-  "arg-${dict.model}ListInPublic-limit": ["Limit", "\uC81C\uD55C"],
-  "argdesc-${dict.model}ListInPublic-limit": ["Maximum number of items to return", "\uBC18\uD658\uD560 \uCD5C\uB300 \uC544\uC774\uD15C \uC218"],
-  "arg-${dict.model}ListInPublic-sort": ["Sort", "\uC815\uB82C"],
-  "argdesc-${dict.model}ListInPublic-sort": ["Sort order of the items", "\uC544\uC774\uD15C\uC758 \uC815\uB82C \uC21C\uC11C"],
-
-  "api-${dict.model}InsightInPublic": ["${dict.Model} Insight In Public", "\uACF5\uAC1C\uB41C ${dict.Model} \uC778\uC0AC\uC774\uD2B8"],
-  "apidesc-${dict.model}InsightInPublic": [
-    "Get insight data for public ${dict.model}",
-    "\uACF5\uAC1C\uB41C ${dict.Model}\uC5D0 \uB300\uD55C \uC778\uC0AC\uC774\uD2B8 \uB370\uC774\uD130\uB97C \uAC00\uC838\uC635\uB2C8\uB2E4",
-  ],
-  "arg-${dict.model}InsightInPublic-statuses": ["Statuses", "\uC0C1\uD0DC"],
-  "argdesc-${dict.model}InsightInPublic-statuses": ["Statuses to filter", "\uD544\uD130\uB9C1\uD560 \uC0C1\uD0DC"],
-  // * ==================== Endpoint ==================== * //
-} satisfies SignalDictionary<${dict.Model}Signal, ${dict.Model}>;
+import { modelDictionary } from "@akanjs/dictionary";
+
+import type { ${dict.Model}, ${dict.Model}Insight } from "./${dict.model}.constant";
+import type { ${dict.Model}Filter } from "./${dict.model}.document";
+import type { ${dict.Model}Endpoint, ${dict.Model}Slice } from "./${dict.model}.signal";
+
+export const dictionary = modelDictionary(["en", "ko"])
+  .of((t) =>
+    t(["${dict.Model}", "${dict.Model}"]).desc(["${dict.Model} description", "${dict.Model} \uC124\uBA85"])
+  )
+  .model<${dict.Model}>((t) => ({
+    field: t(["Field", "\uD544\uB4DC"]).desc(["Field description", "\uD544\uB4DC \uC124\uBA85"]),
+  }))
+  .insight<${dict.Model}Insight>((t) => ({}))
+  .query<${dict.Model}Filter>((fn) => ({}))
+  .slice<${dict.Model}Slice>((fn) => ({
+    inPublic: fn(["${dict.Model} In Public", "${dict.Model} \uACF5\uAC1C"]).arg((t) => ({})),
+  }))
+  .endpoint<${dict.Model}Endpoint>((fn) => ({}))
+  .error({})
+  .translate({});
 `;
 }

package/cjs/src/templates/module/__model__.document.js

@@ -24,7 +24,7 @@ __export(model_document_exports, {
 module.exports = __toCommonJS(model_document_exports);
 function getContent(scanInfo, dict) {
   return `
-import { beyond, by, into, type SchemaOf } from "@akanjs/document";
+import { beyond, by, from, into, type SchemaOf } from "@akanjs/document";
 
 import * as cnst from "../cnst";
 

package/cjs/src/templates/module/__model__.signal.js

@@ -24,18 +24,19 @@ __export(model_signal_exports, {
 module.exports = __toCommonJS(model_signal_exports);
 function getContent(scanInfo, dict) {
   return `
+import { Public } from "@akanjs/nest";
 import { endpoint, internal, slice } from "@akanjs/signal";
+import { Admin } from "@shared/nest";
 
 import * as cnst from "../cnst";
 import * as srv from "../srv";
 
 export class ${dict.Model}Internal extends internal(srv.${dict.model}, () => ({})) {}
 
-export class ${dict.Model}Slice extends slice(srv.${dict.model}, { guards: { get: "Public", cru: "Public" } }, (init) => ({
+export class ${dict.Model}Slice extends slice(srv.${dict.model}, { guards: { root: Admin, get: Public, cru: Public } }, (init) => ({
   inPublic: init()
-    .search("statuses", [cnst.${dict.Model}Status])
-    .exec(function (statuses) {
-      return this.${dict.model}Service.queryByStatuses(statuses);
+    .exec(function () {
+      return this.${dict.model}Service.queryAny();
     }),
 })) {}
 

package/cjs/src/templates/server.js

@@ -31,15 +31,15 @@ function getContent(scanInfo, dict = {}) {
   const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("service"));
   const scalarModules = [...scanInfo.scalar.entries()];
   return `
-import { databaseModuleOf, scalarModulesOf, serviceModuleOf, type Module } from "@akanjs/server";
-${libs.map((lib) => `import { registerModules as register${capitalize(lib)}Modules } from "@${lib}/server";`).join("\n")}
+import { databaseModuleOf, scalarModulesOf, serviceModuleOf, type Module, type Middleware } from "@akanjs/server";
+${libs.map((lib) => `import { registerModules as register${capitalize(lib)}Modules, registerMiddlewares as register${capitalize(lib)}Middlewares } from "@${lib}/server";`).join("\n")}
   
 import * as cnst from "./lib/cnst";
 import * as db from "./lib/db";
 import * as srv from "./lib/srv";
 import { allSrvs } from "./lib/srv";
 import * as sig from "./lib/sig";
-import { type ModulesOptions, registerGlobalModule } from "./lib/option";
+import { type ModulesOptions, registerGlobalModule, registerGlobalMiddlewares } from "./lib/option";
 
 // database modules
 ${databaseModules.map(([model]) => {
@@ -67,6 +67,14 @@ ${databaseModules.map(([model]) => `    register${capitalize(model)}Module(),`).
   return modules;
 };
 
+export const registerMiddlewares = (options: ModulesOptions, isChild?: boolean) => {
+  const middlewares = [
+${libs.map((lib) => `    ...(!isChild ? register${capitalize(lib)}Middlewares(options, true) : []),`).join("\n")}
+    ...registerGlobalMiddlewares(options),
+  ] as Middleware[];
+  return middlewares;
+};
+
 export { env } from "./env/env.server.testing";
 export * as db from "./lib/db";
 export * as srv from "./lib/srv";

package/esm/index.js

@@ -208,7 +208,7 @@ var Logger = class _Logger {
     const contentMsg = this.#colorize(content, logLevel);
     const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
     if (typeof window === "undefined")
-      process[writeStreamType].write(
+      process[writeStreamType]?.write(
         `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
 `
       );
@@ -1986,10 +1986,10 @@ var Executor = class _Executor {
     this.logger.verbose(`Remove file ${readPath}`);
     return this;
   }
-  removeDir(dirPath) {
+  async removeDir(dirPath) {
     const readPath = this.getPath(dirPath);
     if (fs8.existsSync(readPath))
-      fs8.rmSync(readPath, { recursive: true });
+      await fs8.promises.rm(readPath, { recursive: true });
     this.logger.verbose(`Remove directory ${readPath}`);
     return this;
   }
@@ -2035,9 +2035,9 @@ var Executor = class _Executor {
   async cp(srcPath, destPath) {
     const src = this.getPath(srcPath);
     const dest = this.getPath(destPath);
-    const isDirectory = fs8.statSync(src).isDirectory();
     if (!fs8.existsSync(src))
       return;
+    const isDirectory = fs8.statSync(src).isDirectory();
     if (!fs8.existsSync(dest) && isDirectory)
       await fsPromise.mkdir(dest, { recursive: true });
     await fsPromise.cp(src, dest, { recursive: true });
@@ -2593,32 +2593,23 @@ var AppExecutor = class _AppExecutor extends SysExecutor {
     return this.#akanConfig;
   }
   async syncAssets(libDeps) {
-    const projectPublicLibPath = `${this.cwdPath}/public/libs`;
-    const projectAssetsLibPath = `${this.cwdPath}/assets/libs`;
+    const projectPublicPath = `${this.cwdPath}/public`;
+    const projectAssetsPath = `${this.cwdPath}/assets`;
+    const projectPublicLibPath = `${projectPublicPath}/libs`;
+    const projectAssetsLibPath = `${projectAssetsPath}/libs`;
+    await Promise.all([this.removeDir(projectPublicLibPath), this.removeDir(projectAssetsLibPath)]);
+    const targetPublicDeps = libDeps.filter((dep) => this.exists(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
+    const targetAssetsDeps = libDeps.filter((dep) => this.exists(`${this.workspace.workspaceRoot}/libs/${dep}/assets`));
     await Promise.all([
-      fs8.existsSync(projectPublicLibPath) && fsPromise.rm(projectPublicLibPath, { recursive: true }),
-      fs8.existsSync(projectAssetsLibPath) && fsPromise.rm(projectAssetsLibPath, { recursive: true })
-    ]);
-    const targetPublicDeps = libDeps.filter(
-      (dep) => fs8.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`)
-    );
-    const targetAssetsDeps = libDeps.filter(
-      (dep) => fs8.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/assets`)
-    );
-    await Promise.all([
-      ...targetPublicDeps.map((dep) => fsPromise.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })),
-      ...targetAssetsDeps.map((dep) => fsPromise.mkdir(`${projectAssetsLibPath}/${dep}`, { recursive: true }))
+      ...targetPublicDeps.map((dep) => this.mkdir(`${projectPublicLibPath}/${dep}`)),
+      ...targetAssetsDeps.map((dep) => this.mkdir(`${projectAssetsLibPath}/${dep}`))
     ]);
     await Promise.all([
       ...targetPublicDeps.map(
-        (dep) => fsPromise.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
-          recursive: true
-        })
+        (dep) => this.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`)
       ),
       ...targetAssetsDeps.map(
-        (dep) => fsPromise.cp(`${this.workspace.workspaceRoot}/libs/${dep}/assets`, `${projectAssetsLibPath}/${dep}`, {
-          recursive: true
-        })
+        (dep) => this.cp(`${this.workspace.workspaceRoot}/libs/${dep}/assets`, `${projectAssetsLibPath}/${dep}`)
       )
     ]);
   }
@@ -4975,14 +4966,14 @@ var ApplicationScript = class {
   }
   async dumpDatabase(app, environment) {
     await this.dbdown(app.workspace);
-    const spinner = app.spinning("Dumping database...");
+    const spinner = app.spinning(`Dumping database ${app.name} (${environment})...`);
     await this.#runner.dumpDatabase(app, environment);
-    spinner.succeed(`Database dumped to dump/${app.name}-${environment}`);
+    spinner.succeed(`Database ${app.name} (${environment}) dumped to dump/${app.name}-${environment}`);
   }
   async restoreDatabase(app, source, target) {
-    const spinner = app.spinning("Restoring database...");
+    const spinner = app.spinning(`Restoring database ${app.name} (${source}) to ${target}...`);
     await this.#runner.restoreDatabase(app, source, target);
-    spinner.succeed(`Database restored from dump/${app.name}-${source} to ${app.name}-${target}`);
+    spinner.succeed(`Database ${app.name} (${source}) restored to ${target}`);
   }
   async pullDatabase(app, environment, dump) {
     const hasDump = app.workspace.exists(`dump/${app.name}-${environment}`);
@@ -5396,19 +5387,19 @@ ${chalk6.green("\u27A4")} Authentication Required`));
   }
   async deployAkan(workspace, akanPkgs) {
     const basePackageJson = workspace.readJson("pkgs/@akanjs/base/package.json");
-    const majorVersionOfBase = basePackageJson.version.split(".")[0];
-    const minorVersionOfBase = basePackageJson.version.split(".")[1];
-    const getNextVersion = async (major, minor) => {
+    const [majorVersionOfBase, minorVersionOfBase, patchVersionOfBase, devPatchVersionOfBase] = basePackageJson.version.split(".");
+    const targetVersionPrefix = devPatchVersionOfBase ? `${majorVersionOfBase}.${minorVersionOfBase}.${patchVersionOfBase}` : `${majorVersionOfBase}.${minorVersionOfBase}`;
+    const getNextVersion = async (prefix) => {
       try {
-        const latestPublishedVersionOfBase = await latestVersion("@akanjs/base", { version: `${major}.${minor}` });
+        const latestPublishedVersionOfBase = await latestVersion("@akanjs/base", { version: prefix });
         const latestPatch = parseInt(latestPublishedVersionOfBase.split(".")[2]);
-        const nextVersion2 = `${major}.${minor}.${latestPatch + 1}`;
+        const nextVersion2 = `${prefix}.${latestPatch + 1}`;
         return { nextVersion: nextVersion2, latestPublishedVersion: latestPublishedVersionOfBase };
       } catch (e) {
-        return { nextVersion: `${major}.${minor}.0`, latestPublishedVersion: null };
+        return { nextVersion: `${prefix}.0`, latestPublishedVersion: null };
       }
     };
-    const { nextVersion, latestPublishedVersion } = await getNextVersion(majorVersionOfBase, minorVersionOfBase);
+    const { nextVersion, latestPublishedVersion } = await getNextVersion(targetVersionPrefix);
     Logger.info(`Latest published version of @akanjs/base: ${latestPublishedVersion ?? "none"}`);
     Logger.info(`Next version of @akanjs/base: ${nextVersion}`);
     for (const library of akanPkgs) {
@@ -5924,8 +5915,8 @@ var requestUnit = ({
 var ModuleRunner = class {
   async createModule(workspace, sysType, sysName, moduleName, description) {
   }
-  removeModule(module) {
-    module.sys.removeDir(`lib/${module.name}`);
+  async removeModule(module) {
+    await module.sys.removeDir(`lib/${module.name}`);
   }
   async createComponentTemplate(module, type) {
     await module.sys.applyTemplate({
@@ -6062,8 +6053,8 @@ var ModuleScript = class {
     await this.createTemplate(executor);
     sys3.log(`Module ${name} created in ${sys3.type}s/${sys3.name}/lib/${name}`);
   }
-  removeModule(mod) {
-    this.#runner.removeModule(mod);
+  async removeModule(mod) {
+    await this.#runner.removeModule(mod);
   }
   async createService(workspace, name) {
   }
@@ -6141,8 +6132,8 @@ var ModuleCommand = class {
     const name = lowerlize(moduleName.replace(/ /g, ""));
     await this.moduleScript.createModuleTemplate(sys3, name, { page });
   }
-  removeModule(module) {
-    this.moduleScript.removeModule(module);
+  async removeModule(module) {
+    await this.moduleScript.removeModule(module);
   }
   async createView(module) {
     await this.moduleScript.createView(module);
@@ -6395,6 +6386,16 @@ var WorkspaceScript = class {
     for (const appName of appNames)
       await this.applicationScript.syncApplication(AppExecutor.from(workspace, appName));
   }
+  async dumpDatabaseAll(workspace, environment) {
+    const appNames = await workspace.getApps();
+    for (const appName of appNames)
+      await this.applicationScript.dumpDatabase(AppExecutor.from(workspace, appName), environment);
+  }
+  async restoreDatabaseAll(workspace, source, target) {
+    const appNames = await workspace.getApps();
+    for (const appName of appNames)
+      await this.applicationScript.restoreDatabase(AppExecutor.from(workspace, appName), source, target);
+  }
 };
 
 // pkgs/@akanjs/cli/src/workspace/workspace.command.ts
@@ -6419,6 +6420,12 @@ var WorkspaceCommand = class {
   async syncAll(workspace) {
     await this.workspaceScript.syncAll(workspace);
   }
+  async dumpDatabaseAll(environment, workspace) {
+    await this.workspaceScript.dumpDatabaseAll(workspace, environment);
+  }
+  async restoreDatabaseAll(source, target, workspace) {
+    await this.workspaceScript.restoreDatabaseAll(workspace, source, target);
+  }
 };
 __decorateClass([
   Target.Public(),
@@ -6445,6 +6452,30 @@ __decorateClass([
   Target.Public(),
   __decorateParam(0, Workspace())
 ], WorkspaceCommand.prototype, "syncAll", 1);
+__decorateClass([
+  Target.Public(),
+  __decorateParam(0, Option("environment", {
+    desc: "environment",
+    default: "debug",
+    enum: ["debug", "develop", "main"],
+    ask: "Select the environment to dump the database"
+  })),
+  __decorateParam(1, Workspace())
+], WorkspaceCommand.prototype, "dumpDatabaseAll", 1);
+__decorateClass([
+  Target.Public(),
+  __decorateParam(0, Option("source", {
+    desc: "source environment",
+    enum: ["debug", "develop", "main"],
+    ask: "Select the source environment of local dump"
+  })),
+  __decorateParam(1, Option("target", {
+    desc: "target environment",
+    enum: ["debug", "develop", "main"],
+    ask: "Select the target environment to restore the database"
+  })),
+  __decorateParam(2, Workspace())
+], WorkspaceCommand.prototype, "restoreDatabaseAll", 1);
 WorkspaceCommand = __decorateClass([
   Commands()
 ], WorkspaceCommand);
@@ -6941,8 +6972,8 @@ var ScalarScript = class {
     const { session, scalarNames } = await this.#runner.createScalarConstant(sys3, scalarName);
     await this.#runner.updateScalarDictionaries(sys3, scalarNames, { session });
   }
-  removeScalar(sys3, scalarName) {
-    sys3.removeDir(`lib/__scalar/${scalarName}`);
+  async removeScalar(sys3, scalarName) {
+    await sys3.removeDir(`lib/__scalar/${scalarName}`);
   }
 };
 
@@ -6952,8 +6983,8 @@ var ScalarCommand = class {
   async createScalar(sys3, scalarName) {
     await this.scalarScript.createScalar(sys3, lowerlize(scalarName.replace(/ /g, "")));
   }
-  removeScalar(sys3, scalarName) {
-    this.scalarScript.removeScalar(sys3, scalarName);
+  async removeScalar(sys3, scalarName) {
+    await this.scalarScript.removeScalar(sys3, scalarName);
   }
 };
 __decorateClass([

package/esm/src/guidelines/databaseModule/databaseModule.instruction.md

@@ -207,7 +207,7 @@ import * as cnst from "../cnst";
 import type * as db from "../db";
 
 export class UserSignal extends DbSignal(cnst.userCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Admin },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.Admin },
 }) {
   @Mutation.Public(() => cnst.util.AccessToken)
   async signin(
@@ -578,30 +578,36 @@ export const Layout = () => (
 ## Best Practices
 
 1. **Naming Conventions**
+
    - Use PascalCase for classes and components (e.g., `UserService`, `User.Unit.tsx`)
    - Use camelCase for files (e.g., `user.service.ts`, `user.document.ts`)
 
 2. **Security**
+
    - Use `@Field.Secret` for sensitive data like passwords
    - Apply proper permission guards to queries and mutations (`@Query.Admin`, `@Mutation.Public`)
    - Validate input data using the `validate` option in `@Field.Prop`
 
 3. **Code Organization**
+
    - Keep business logic in service files
    - Use signals for API calls only, not for business logic
    - Define reusable utility methods in document models
 
 4. **Performance**
+
    - Use dataloader pattern (`@Loader.ByField`) for efficient database access
    - Create proper indexes in the middleware
    - Use projections to limit returned fields when appropriate
 
 5. **Testing**
+
    - Create signal tests for each API endpoint
    - Mock services for unit testing signals
    - Use integration tests for testing complex workflows
 
 6. **UI Components**
+
    - Follow the separation between Template, Unit, View, and Zone components
    - Make components reusable across different parts of the application
    - Use dictionary files for all UI text to support internationalization

package/esm/src/guidelines/modelSignal/modelSignal.instruction.md

@@ -27,7 +27,7 @@ import * as cnst from "../cnst";
 import type * as db from "../db";
 
 export class ModelNameSignal extends DbSignal(cnst.modelNameCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.User },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.User },
 }) {
   // Signal methods here...
 }
@@ -259,7 +259,7 @@ DbSignal creates standard operations that you don't need to implement:
 
 ```typescript
 export class BoardSignal extends DbSignal(cnst.boardCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Admin },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.Admin },
 }) {
   // Custom methods beyond CRUD go here
 }
@@ -378,7 +378,7 @@ async getProjectDetails(
 
 ```typescript
 export class ProductSignal extends DbSignal(cnst.productCnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Admin },
+  guards: { root: Admin, get: Query.Public, cru: Mutation.Admin },
 }) {
   // Custom methods beyond auto-generated CRUD
   @Query.Public(() => [cnst.Product])

package/esm/src/guidelines/modelTemplate/modelTemplate.instruction.md

@@ -49,7 +49,7 @@ export const General = ({ id }: { id?: string }) => {
   return (
     <div className="grid grid-cols-1 gap-4">
       <Field.Text
-        label={l.field("model", "fieldName")}
+        label={l("model.fieldName")}
         value={form.fieldName}
         onChange={(v) => st.do.setFieldNameOn[Model](v)}
       />
@@ -139,7 +139,7 @@ useEffect(() => {
 
 ```tsx
 <Field.List
-  label={l.field("map", "spawnPositions")}
+  label={l("map.spawnPositions")}
   value={form.spawnPositions}
   onAdd={() => st.do.addSpawnPosition(defaultPosition)}
   renderItem={(position, idx) => (
@@ -201,12 +201,12 @@ useEffect(() => {
 const { l } = usePage();
 
 // Basic field
-<Field.Text label={l.field("model", "name")} />
+<Field.Text label={l("model.name")} />
 
 // With description
 <Field.Text
-  label={l.field("model", "email")}
-  desc={l.desc("model", "email")}
+  label={l("model.email")}
+  desc={l("model.email.desc")}
 />
 
 // Dynamic content

package/esm/src/guidelines/sharedUiUsage/sharedUiUsage.generate.json

@@ -85,13 +85,6 @@
       "path": "{apps,libs}/*/lib/*/*.{Template,Unit,View,Zone}.tsx",
       "filterText": "sliceName",
       "sample": 5
-    },
-    {
-      "type": "example",
-      "description": "Internationalization usage examples",
-      "path": "{apps,libs}/*/lib/*/*.{Template,Unit,View}.tsx",
-      "filterText": "l.field",
-      "sample": 3
     }
   ],
   "update": {

package/esm/src/guidelines/sharedUiUsage/sharedUiUsage.instruction.md

@@ -64,8 +64,8 @@ const MyComponent = () => {
   return (
     <>
       <Field.Text
-        label={l.field("myModel", "title")}
-        desc={l.desc("myModel", "title")}
+        label={l("myModel.title")}
+        desc={l("myModel.title.desc")}
         value={formState.title}
         onChange={(value) => st.do.setTitleOnMyModel(value)}
         nullable={false}
@@ -73,8 +73,8 @@ const MyComponent = () => {
       />
 
       <Field.Number
-        label={l.field("myModel", "amount")}
-        desc={l.desc("myModel", "amount")}
+        label={l("myModel.amount")}
+        desc={l("myModel.amount.desc")}
         value={formState.amount}
         onChange={(value) => st.do.setAmountOnMyModel(value)}
         min={0}
@@ -83,8 +83,8 @@ const MyComponent = () => {
       />
 
       <Field.ToggleSelect
-        label={l.field("myModel", "status")}
-        desc={l.desc("myModel", "status")}
+        label={l("myModel.status")}
+        desc={l("myModel.status.desc")}
         value={formState.status}
         items={cnst.Status}
         onChange={(status) => st.do.setStatusOnMyModel(status)}
@@ -266,7 +266,7 @@ Components automatically integrate with the internationalization system:
 ```tsx
 const { l } = usePage();
 
-<Field.Text label={l.field("user", "name")} desc={l.desc("user", "name")} placeholder={l("user.namePlaceholder")} />;
+<Field.Text label={l("user.name")} desc={l("user.name.desc")} placeholder={l("user.namePlaceholder")} />;
 ```
 
 ### State Management Integration

package/esm/src/templates/app/app/[lang]/layout.js

@@ -8,6 +8,7 @@ import { RootLayoutProps } from "@akanjs/client";
 import { System } from "@akanjs/ui";
 import { env } from "@${dict.appName}/env/env.client";
 import { fetch } from "@${dict.appName}/client";
+import { Auth } from "@shared/ui";
 
 export const metadata = { title: "${dict.appName}" };
 
@@ -22,6 +23,7 @@ export default function Layout({ children, params }: RootLayoutProps) {
       env={env}
     >
       {children}
+      <Auth.User />
     </System.Provider>
   );
 }

package/esm/src/templates/app/app/[lang]/styles.css.template

@@ -3,6 +3,7 @@
 
 @plugin "daisyui" {
   logs: false;
+  exclude: properties;
 }
 
 @plugin "daisyui/theme" {

package/esm/src/templates/app/lib/option.js

@@ -1,7 +1,7 @@
 // pkgs/@akanjs/cli/src/templates/app/lib/option.ts
 function getContent(scanInfo, dict = {}) {
   return `
-import { useGlobals } from "@akanjs/server";
+import { Middleware, useGlobals } from "@akanjs/server";
 
 import type { LibOptions } from "./__lib/lib.service";
 
@@ -15,6 +15,11 @@ export const registerGlobalModule = (options: ModulesOptions) => {
     useAsyncs: {},
   });
 };
+
+export const registerGlobalMiddlewares = (options: ModulesOptions) => {
+  return [] as Middleware[];
+};
+
   `;
 }
 export {

package/esm/src/templates/app/main.js

@@ -4,12 +4,12 @@ function getContent(scanInfo, dict) {
 import { createNestApp } from "@akanjs/server";
 
 import { env } from "./env/env.server";
-import { registerModules } from "./server";
+import { registerModules, registerMiddlewares } from "./server";
 
 const bootstrap = async () => {
   const serverMode = process.env.SERVER_MODE as "federation" | "batch" | "all" | null;
   if (!serverMode) throw new Error("SERVER_MODE environment variable is not defined");
-  await createNestApp({ registerModules, serverMode, env });
+  await createNestApp({ registerModules, registerMiddlewares, serverMode, env });
 };
 void bootstrap();
   `;

package/esm/src/templates/lib/__lib/lib.dictionary.js

@@ -19,8 +19,7 @@ ${libs.map((lib) => `import { dict as ${lib} } from "@${lib}/server";`).join("\n
 
 ${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
     return `export const ${modelName} = {
-  models: Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}.modelDictionary`).join(", ")}),
-  signals: Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}.signalDictionary`).join(", ")}),
+  dictionaries: [${extendedModels2.map((libName) => `${libName}.${modelName}.dictionary`).join(", ")}] as const,
 };`;
   }).join("\n")}