@akanjs/cli 0.9.42 → 0.9.44

package/cjs/src/guidelines/modelService/modelService.instruction.md

@@ -136,97 +136,6 @@ Injects a websocket server instance for real-time communication:
 protected readonly websocket: Websocket<ChatSignal>;
 ```
 
-## Lifecycle Methods
-
-Akan.js services can implement lifecycle hooks that are called by the NestJS framework.
-
-### onModuleInit()
-
-Called once the module has been initialized by NestJS. Use this for setup operations:
-
-```typescript
-async onModuleInit() {
-  // Initialize service resources
-  await this.loadInitialData();
-  this.setupEventListeners();
-  this.logger.log('Service initialized successfully');
-}
-```
-
-Common use cases:
-
-- Initializing in-memory cache
-- Setting up event listeners
-- Loading configuration data
-- Establishing connections to external services
-
-### onModuleDestroy()
-
-Called just before the application shuts down. Use this for cleanup operations:
-
-```typescript
-async onModuleDestroy() {
-  // Clean up resources
-  await Promise.all(this.connections.map(conn => conn.close()));
-  this.clearTimers();
-  this.logger.log('Service resources released');
-}
-```
-
-Common use cases:
-
-- Closing database connections
-- Releasing external resources
-- Clearing timers and intervals
-- Unregistering event listeners
-
-## Scheduled Tasks
-
-Akan.js provides decorators for scheduling recurring tasks.
-
-### @Cron Decorator
-
-Executes methods on a cron schedule:
-
-```typescript
-@Cron("0 0 * * *")  // Run at midnight every day
-async dailyCleanup() {
-  await this.cleanupExpiredRecords();
-  this.logger.log('Daily cleanup completed');
-}
-
-@Cron("*/5 * * * *", { serverMode: "batch" })  // Run every 5 minutes, only in batch mode
-async periodicSync() {
-  await this.syncExternalData();
-}
-```
-
-The first parameter uses standard cron syntax:
-
-- `* * * * *` = minute hour day-of-month month day-of-week
-- Special patterns like `@daily`, `@hourly` are also supported
-
-Options include:
-
-- `serverMode`: Restrict to a specific server mode (e.g., "batch")
-- `name`: Assign a name to the scheduled job
-- `timeZone`: Specify the timezone for the schedule
-
-### @Interval Decorator
-
-Executes methods at fixed time intervals in milliseconds:
-
-```typescript
-@Interval(60000)  // Run every minute (60,000 ms)
-async checkStatus() {
-  await this.monitorSystemHealth();
-}
-```
-
-Options:
-
-- `name`: Assign a name to the interval
-
 ## Database Operations
 
 When extending `DbService`, your service automatically inherits numerous methods for working with the database model.
@@ -606,34 +515,6 @@ class PaymentService extends DbService(db.paymentDb) {
 }
 ```
 
-### 3. Proper Resource Management
-
-Clean up resources in lifecycle hooks:
-
-```typescript
-@Service("ExternalApiService")
-class ExternalApiService extends LogService("ExternalApiService") {
-  private client: ApiClient;
-  private timers: NodeJS.Timeout[] = [];
-
-  async onModuleInit() {
-    this.client = new ApiClient();
-    await this.client.connect();
-
-    this.timers.push(setInterval(() => this.refreshToken(), 3600000));
-  }
-
-  async onModuleDestroy() {
-    // Clean up resources
-    await this.client.disconnect();
-
-    for (const timer of this.timers) {
-      clearInterval(timer);
-    }
-  }
-}
-```
-
 ### 4. Transaction Safety
 
 Use hooks for validating operations:
@@ -724,7 +605,7 @@ import { Cron } from "@akanjs/nest";
 import { DbService, Service, Srv, Use } from "@akanjs/service";
 import type { EmailApi } from "@util/nest";
 
-import { cnst } from "../cnst";
+import * as cnst from "../cnst";
 import * as db from "../db";
 import { Revert } from "../dict";
 import type * as srv from "../srv";
@@ -818,25 +699,6 @@ export class OrderService extends DbService(db.orderDb) {
 
     return data;
   }
-
-  // Scheduled task
-  @Cron("0 0 * * *", { serverMode: "batch" })
-  async cleanupAbandonedOrders() {
-    const cutoffDate = dayjs().subtract(7, "days");
-    const orders = await this.listPendingOrders(cutoffDate);
-
-    for (const order of orders) {
-      await this.cancelOrder(order.id);
-      this.logger.log(`Cancelled abandoned order: ${order.id}`);
-    }
-  }
-
-  // Summary method
-  async summarize(): Promise<cnst.OrderSummary> {
-    return {
-      ...(await this.orderModel.getSummary()),
-    };
-  }
 }
 ```
 
@@ -894,32 +756,6 @@ If a service isn't being injected correctly:
    }
    ```
 
-### Scheduled Tasks Not Running
-
-1. Verify cron syntax:
-
-   ```typescript
-   // Correct syntax
-   @Cron("0 * * * *")  // Every hour at minute 0
-
-   // Incorrect syntax
-   @Cron("0 * * *")  // Missing day-of-week field
-   ```
-
-2. Check server mode restrictions:
-
-   ```typescript
-   // Only runs in batch mode
-   @Cron("0 * * * *", { serverMode: "batch" })
-   ```
-
-3. Ensure the service is properly initialized:
-   ```typescript
-   onModuleInit() {
-     this.logger.log('Service initialized');  // Is this being logged?
-   }
-   ```
-
 ## Summary
 
 Model services in Akan.js are powerful components that encapsulate business logic and data operations. By following the patterns and best practices outlined in this guide, you can create maintainable, scalable services that effectively implement your application's domain logic while maintaining clean separation of concerns.

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

@@ -23,11 +23,11 @@ import { ID, Int } from "@akanjs/base";
 import { SortOf } from "@akanjs/constant";
 import { Arg, DbSignal, Mutation, Query, resolve, Self, Signal } from "@akanjs/signal";
 
-import { cnst, Srvs } from "../cnst";
+import * as cnst from "../cnst";
 import type * as db from "../db";
 
 @Signal(() => cnst.ModelName)
-export class ModelNameSignal extends DbSignal(cnst.modelNameCnst, Srvs, {
+export class ModelNameSignal extends DbSignal(cnst.modelNameCnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.User },
 }) {
   // Signal methods here...
@@ -289,7 +289,7 @@ DbSignal creates standard operations that you don't need to implement:
 
 ```typescript
 @Signal(() => cnst.Board)
-export class BoardSignal extends DbSignal(cnst.boardCnst, Srvs, {
+export class BoardSignal extends DbSignal(cnst.boardCnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.Admin },
 }) {
   // Custom methods beyond CRUD go here
@@ -409,7 +409,7 @@ async getProjectDetails(
 
 ```typescript
 @Signal(() => cnst.Product)
-export class ProductSignal extends DbSignal(cnst.productCnst, Srvs, {
+export class ProductSignal extends DbSignal(cnst.productCnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.Admin },
 }) {
   // Custom methods beyond auto-generated CRUD

package/cjs/src/guidelines/modelStore/modelStore.instruction.md

@@ -34,8 +34,8 @@ Model stores follow a consistent architecture pattern:
 
 ```typescript
 import { stateOf, Store } from "@akanjs/store";
-import { cnst } from "../cnst";
-import { fetch } from "../fetch";
+import * as cnst from "../cnst";
+import { fetch } from "../sig";
 
 @Store(() => cnst.Product)
 export class ProductStore extends stateOf(fetch.productGql, {
@@ -485,8 +485,8 @@ initProductChat(productId: string) {
 
 ```typescript
 import { stateOf, Store, Toast } from "@akanjs/store";
-import { cnst } from "../cnst";
-import { fetch } from "../fetch";
+import * as cnst from "../cnst";
+import { fetch } from "../sig";
 import { msg } from "../msg";
 
 @Store(() => cnst.Product)

package/cjs/src/templates/app/lib/___appName__/__appName__.dictionary.js

@@ -24,8 +24,13 @@ __export(appName_dictionary_exports, {
 module.exports = __toCommonJS(appName_dictionary_exports);
 function getContent(scanInfo, dict) {
   return `
+import type { SignalDictionary } from "@akanjs/dictionary";
+import type { ${dict.AppName}Signal } from "./${dict.appName}.signal";
+
 const dictionary = {} as const;
 
-export const ${dict.appName}Dictionary = dictionary;
+const signalDictionary = {} satisfies SignalDictionary<${dict.AppName}Signal>;
+
+export const ${dict.appName}Dictionary = { ...dictionary, ...signalDictionary };
   `;
 }

package/cjs/src/templates/app/lib/___appName__/__appName__.service.js

@@ -24,19 +24,9 @@ __export(appName_service_exports, {
 module.exports = __toCommonJS(appName_service_exports);
 function getContent(scanInfo, dict) {
   return `
-import { Cron } from "@akanjs/nest";
-import { LogService, Service, Srv } from "@akanjs/service";
-
-import type * as srv from "../srv";
+import { LogService, Service } from "@akanjs/service";
 
 @Service("${dict.appName}Service", { serverMode: "batch" })
-export class ${dict.AppName}Service extends LogService("${dict.appName}Service") {
-  @Srv() protected readonly summaryService: srv.SummaryService;
-
-  @Cron("0 * * * *")
-  async takePeriodicSnapshot() {
-    await this.summaryService.makeSummary();
-  }
-}
-  `;
+export class ${dict.AppName}Service extends LogService("${dict.appName}Service") {}
+`;
 }

package/cjs/src/templates/app/lib/{user/user.signal.js → ___appName__/__appName__.signal.js}

@@ -16,19 +16,19 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// pkgs/@akanjs/cli/src/templates/app/lib/user/user.signal.ts
-var user_signal_exports = {};
-__export(user_signal_exports, {
+// pkgs/@akanjs/cli/src/templates/app/lib/___appName__/__appName__.signal.ts
+var appName_signal_exports = {};
+__export(appName_signal_exports, {
   default: () => getContent
 });
-module.exports = __toCommonJS(user_signal_exports);
-function getContent(scanInfo, dict = {}) {
+module.exports = __toCommonJS(appName_signal_exports);
+function getContent(scanInfo, dict) {
   return `
 import { LogSignal, Signal } from "@akanjs/signal";
 
-import { cnst, Srvs } from "../cnst";
+import * as cnst from "../cnst";
 
-@Signal(() => cnst.User)
-export class UserSignal extends LogSignal(Srvs) {}
+@Signal({ name: "${dict.AppName}" })
+export class ${dict.AppName}Signal extends LogSignal(cnst.Srvs) {}
   `;
 }

package/cjs/src/templates/client.js

@@ -36,11 +36,10 @@ function getContent(scanInfo, dict = {}) {
     ([_, fileTypes]) => fileTypes.has("template") || fileTypes.has("unit") || fileTypes.has("util") || fileTypes.has("view") || fileTypes.has("zone")
   ).map(([key]) => key);
   return `
-export { st } from "./lib/st";
-export { store } from "./lib/store";
-export { usePage } from "./lib/usePage";
-export { fetch } from "./lib/fetch";
-export { cnst } from "./lib/cnst";
+export { Revert, msg, usePage } from "./lib/usePage";
+export { st, store } from "./lib/st";
+export { fetch } from "./lib/sig";
+export * as cnst from "./lib/cnst"
 ${scalarModules.map((module2) => `export { ${capitalize(module2)} } from "./lib/__scalar/${module2}";`).join("\n")}
 ${serviceModules.map((module2) => `export { ${capitalize(module2)} } from "./lib/_${module2}";`).join("\n")}
 ${databaseModules.map((module2) => `export { ${capitalize(module2)} } from "./lib/${module2}";`).join("\n")}

package/cjs/src/templates/index.js

@@ -24,8 +24,7 @@ __export(templates_exports, {
 module.exports = __toCommonJS(templates_exports);
 function getContent(scanInfo, dict = {}) {
   return `
-export { cnst } from "./lib/cnst";
-export { fetch } from "./lib/fetch";
-export * from "./lib/dict";
+export * as cnst from "./lib/cnst";
+export { fetch } from "./lib/sig";
 `;
 }

package/cjs/src/templates/lib/__lib/lib.constant.js

@@ -22,28 +22,38 @@ __export(lib_constant_exports, {
   default: () => getContent
 });
 module.exports = __toCommonJS(lib_constant_exports);
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
   const scanResult = scanInfo.getScanResult();
   const libs = scanResult.akanConfig.libs;
   const libInfos = scanInfo.getLibInfos();
-  const userLibs = libs.filter((libName) => libInfos.get(libName)?.file.constant.databases.has("user"));
-  const settingLibs = libs.filter((libName) => libInfos.get(libName)?.file.constant.databases.has("setting"));
-  const summaryLibs = libs.filter((libName) => libInfos.get(libName)?.file.constant.databases.has("summary"));
+  const extendedModels = Object.fromEntries(
+    [...scanInfo.file.constant.databases].map(
+      (modelName) => [
+        modelName,
+        [...libInfos.values()].filter((libInfo) => libInfo.file.constant.databases.has(modelName)).map((libInfo) => libInfo.name)
+      ]
+    ).filter(([_, libNames]) => libNames.length > 0)
+  );
   return `
 ${libs.map((lib) => `import { cnst as ${lib} } from "@${lib}";`).join("\n")}
 
 ${libs.map((lib) => `export { cnst as ${lib} } from "@${lib}";`).join("\n")}
 
-${scanResult.akanConfig.rootLib ? `export const root = ${scanResult.akanConfig.rootLib};` : ""}
-export const libSummaries = [${summaryLibs.map((lib) => `${lib}.Summary`).join(", ")}] as const;
-export const libSettings = [${settingLibs.map((lib) => `${lib}.Setting`).join(", ")}] as const;
-export const libSettingInputs = [${settingLibs.map((lib) => `${lib}.SettingInput`).join(", ")}] as const;
-export const libUserInputs = [${userLibs.map((lib) => `${lib}.UserInput`).join(", ")}] as const;
-export const libUsers = [${userLibs.map((lib) => `${lib}.User`).join(", ")}] as const;
-export const libUserInsights = [${userLibs.map((lib) => `${lib}.UserInsight`).join(", ")}] as const;
-export const libUserSummaries = [${userLibs.map((lib) => `${lib}.UserSummary`).join(", ")}] as const;
-export const libUserFilters = [${userLibs.map((lib) => `${lib}.UserFilter`).join(", ")}] as const;
+${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  inputs: [${extendedModels2.map((libName) => `${libName}.${ModelName}Input`).join(", ")}] as const,
+  objects: [${extendedModels2.map((libName) => `${libName}.${ModelName}Object`).join(", ")}] as const,
+  lights: [${extendedModels2.map((libName) => `${libName}.Light${ModelName}`).join(", ")}] as const,
+  models: [${extendedModels2.map((libName) => `${libName}.${ModelName}`).join(", ")}] as const,
+  insights: [${extendedModels2.map((libName) => `${libName}.${ModelName}Insight`).join(", ")}] as const,
+  filters: [${extendedModels2.map((libName) => `${libName}.${ModelName}Filter`).join(", ")}] as const,
+}`;
+  }).join("\n")}
+
+export const allLibs = [${libs.join(", ")}] as const;
 `;
 }

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

@@ -25,18 +25,25 @@ module.exports = __toCommonJS(lib_dictionary_exports);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
-  const libs = scanInfo.getLibs();
-  const moduleDictionaries = [...scanInfo.file.dictionary.databases].filter(
-    (module2) => module2 !== "summary" && module2 !== "setting"
+  const scanResult = scanInfo.getScanResult();
+  const libs = scanInfo.akanConfig.libs;
+  const libInfos = scanInfo.getLibInfos();
+  const extendedModels = Object.fromEntries(
+    [...scanInfo.file.dictionary.databases].map(
+      (modelName) => [
+        modelName,
+        [...libInfos.values()].filter((libInfo) => libInfo.file.dictionary.databases.has(modelName)).map((libInfo) => libInfo.name)
+      ]
+    ).filter(([_, libNames]) => libNames.length > 0)
   );
   return `
 ${libs.length === 0 ? `import { dictionary as base } from "@akanjs/dictionary";` : ""}
-${libs.map((lib) => `import { dictionary as ${lib} } from "@${lib}";`).join("\n")}
+${libs.map((lib) => `import { dictionary as ${lib} } from "@${lib}/server";`).join("\n")}
 
-${moduleDictionaries.map((module2) => `import { ${module2}SummaryDictionary } from "../${module2}/${module2}.dictionary";`).join("\n")}
+${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
+    return `export const ${modelName} = Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}`).join(", ")});`;
+  }).join("\n")}
 
-export const libDictionaries = [${libs.length === 0 ? "base" : libs.join(", ")}] as const;
-
-export const libSummaryDictionary = { ${moduleDictionaries.map((module2) => `...${module2}SummaryDictionary`).join(", ")} };
+export const allLibs = [${libs.length === 0 ? "base" : libs.join(", ")}] as const;
 `;
 }

package/cjs/src/templates/lib/__lib/lib.document.js

@@ -26,16 +26,26 @@ function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
   const libs = scanInfo.getLibs();
-  const rootLib = scanInfo.akanConfig.rootLib;
+  const libInfos = [...scanInfo.getLibInfos().values()];
+  const extendedModels = Object.fromEntries(
+    [...scanInfo.file.document.databases].map(
+      (modelName) => [
+        modelName,
+        libInfos.filter((libInfo) => libInfo.file.document.databases.has(modelName)).map((libInfo) => libInfo.name)
+      ]
+    ).filter(([_, libNames]) => libNames.length > 0)
+  );
   return `
 ${libs.map((lib) => `import { db as ${lib} } from "@${lib}/server";`).join("\n")}
-
 ${libs.map((lib) => `export { db as ${lib} } from "@${lib}/server";`).join("\n")}
 
-${rootLib ? `export const root = ${rootLib};` : ""}
-${rootLib ? `export const rootUser = ${rootLib}.userDb;` : ""}
-${rootLib ? `export const rootSetting = ${rootLib}.settingDb;` : ""}
-${rootLib ? `export const rootSummary = ${rootLib}.summaryDb;` : ""}
-export const libDbs = [${libs.join(", ")}] as const;
+${Object.entries(extendedModels).map(
+    ([modelName, extendedModels2]) => `export const ${modelName} = {
+  inputs: [${extendedModels2.map((libName) => `${libName}.${modelName}Db.Input`).join(", ")}] as const,
+  docs: [${extendedModels2.map((libName) => `${libName}.${modelName}Db.Doc`).join(", ")}] as const,
+  models: [${extendedModels2.map((libName) => `${libName}.${modelName}Db.Model`).join(", ")}] as const,
+}`
+  ).join("\n")}
+export const allLibs = [${libs.join(", ")}] as const;
 `;
 }

package/cjs/src/templates/lib/__lib/lib.service.js

@@ -28,16 +28,16 @@ function getContent(scanInfo, dict = {}) {
     return null;
   const libs = scanInfo.getLibs();
   const libInfos = [...scanInfo.getLibInfos().values()];
-  const libInfosHasSummary = libInfos.filter((libInfo) => libInfo.database.has("summary"));
-  const databaseModules = scanInfo.getDatabaseModules();
-  const databaseModulesWithoutExtendModels = databaseModules.filter(
-    (module2) => !["summary", "setting", "user"].includes(module2)
+  const extendedModels = Object.fromEntries(
+    [...scanInfo.file.service.databases].map(
+      (modelName) => [
+        modelName,
+        libInfos.filter((libInfo) => libInfo.file.service.databases.has(modelName)).map((libInfo) => libInfo.name)
+      ]
+    ).filter(([_, libNames]) => libNames.length > 0)
   );
-  const userLibInfos = libInfos.filter((libInfo) => libInfo.database.has("user"));
-  const settingLibInfos = libInfos.filter((libInfo) => libInfo.database.has("setting"));
-  const summaryLibInfos = libInfos.filter((libInfo) => libInfo.database.has("summary"));
   return `
-${libs.length ? libInfosHasSummary.length ? `import { ExtendedSummaryService, MixSrvs, Srv } from "@akanjs/service";` : `import { DbService, Srv } from "@akanjs/service";` : `import type { BackendEnv } from "@akanjs/base";`}
+${libs.length ? `import { DbService, Srv } from "@akanjs/service";` : `import type { BackendEnv } from "@akanjs/base";`}
 ${libs.map((lib) => `import { option as ${lib}Option, srv as ${lib} } from "@${lib}/server";`).join("\n")}
 
 import * as db from "../db";
@@ -45,34 +45,15 @@ import type * as srv from "../srv";
 
 ${libs.map((lib) => `export { srv as ${lib} } from "@${lib}/server";`).join("\n")}
 
-${summaryLibInfos.length > 0 ? `export const LibSummaryService = MixSrvs(${summaryLibInfos.map((libInfo) => `${libInfo.name}.SummaryService`).join(", ")});` : ""}
-${settingLibInfos.length > 0 ? `export const LibSettingService = MixSrvs(${settingLibInfos.map((libInfo) => `${libInfo.name}.SettingService`).join(", ")});` : ""}
-${userLibInfos.length > 0 ? `export const LibUserService = MixSrvs(${userLibInfos.map((libInfo) => `${libInfo.name}.UserService`).join(", ")});` : ""}
+${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  services: [${extendedModels2.map((libName) => `${libName}.${ModelName}Service`).join(", ")}] as const,
+}`;
+  }).join("\n")}
 
 export const libAllSrvs = { ${libs.map((lib) => `...${lib}.allSrvs`).join(", ")} };
 
 export type LibOptions = ${libs.length ? libs.map((lib) => `${lib}Option.ModulesOptions`).join(" & ") : "BackendEnv"};
-${libs.length ? `
-export class ProtoSummaryService extends ${libInfosHasSummary.length ? "ExtendedSummaryService(db.summaryDb, LibSummaryService)" : "DbService(db.summaryDb)"} {
-  @Srv() protected readonly userService: srv.UserService;
-${databaseModulesWithoutExtendModels.map((module2) => `  @Srv() protected readonly ${module2}Service: srv.${capitalize(module2)}Service;`).join("\n")}
-  
-  async get${capitalize(scanInfo.name)}Summary() {
-    return {
-${databaseModulesWithoutExtendModels.map((module2) => `      ...(await this.${module2}Service.summarize()),`).join("\n")}
-      ...(await this.userService.summarize${capitalize(scanInfo.name)}()),
-    };
-  }
-${scanInfo.exec.type === "app" ? `
-  async makeSummary(archiveType: "periodic" | "non-periodic" = "non-periodic"): Promise<db.Summary> {
-    const summary = {
-${libInfosHasSummary.map((libInfo) => `      ...(await this.get${capitalize(libInfo.name)}Summary()),`).join("\n")}
-      ...(await this.get${capitalize(scanInfo.name)}Summary()),
-    };
-    return (await this.summaryModel.archive(archiveType, summary)) as unknown as db.Summary;
-  }
-` : ""}
-}
-` : ""}
 `;
 }

package/cjs/src/templates/lib/cnst.js

@@ -22,11 +22,29 @@ __export(cnst_exports, {
   default: () => getContent
 });
 module.exports = __toCommonJS(cnst_exports);
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
+  if (!scanInfo)
+    return null;
+  const databaseModules = scanInfo.getDatabaseModules();
+  const scalarModules = scanInfo.getScalarModules();
   return `
 import type { AllSrvs } from "./srv";
+import { cnstOf, scalarCnstOf } from "@akanjs/constant";
+
+${databaseModules.map((module2) => `import * as ${module2} from "./${module2}/${module2}.constant";`).join("\n")}
+${scalarModules.map((module2) => `import { ${capitalize(module2)} } from "./__scalar/${module2}/${module2}.constant";`).join("\n")}
+
+export * from "./__lib/lib.constant";
+${databaseModules.map((module2) => `export * from "./${module2}/${module2}.constant";`).join("\n")}
+${scalarModules.map((module2) => `export * from "./__scalar/${module2}/${module2}.constant";`).join("\n")}
+
+${databaseModules.map((module2) => {
+    const names = { Module: capitalize(module2) };
+    return `export const ${module2}Cnst = cnstOf("${module2}" as const, ${module2}.${names.Module}Input, ${module2}.${names.Module}, ${module2}.Light${names.Module}, ${module2}.${names.Module}Insight, ${module2}.${names.Module}Filter);`;
+  }).join("\n")}
+${scalarModules.map((module2) => `export const ${module2}Cnst = scalarCnstOf("${module2}" as const, ${capitalize(module2)});`).join("\n")}
 
-export * as cnst from "./cnst_";
 export const Srvs = {} as AllSrvs;
 `;
 }

package/cjs/src/templates/lib/db.js

@@ -27,12 +27,10 @@ function getContent(scanInfo, dict = {}) {
     return null;
   const databaseModules = scanInfo.getDatabaseModules();
   const scalarModules = scanInfo.getScalarModules();
-  const rootLib = scanInfo.akanConfig.rootLib;
   return `
 import { dbOf } from "@akanjs/document";
 
-${rootLib ? `import { root } from "./__lib/lib.constant";` : ""}
-import { cnst } from "./cnst";
+import * as cnst from "./cnst";
 
 ${databaseModules.map((module2) => `import * as ${module2} from "./${module2}/${module2}.document";`).join("\n")}
 
@@ -41,13 +39,8 @@ ${databaseModules.map((module2) => `export type * from "./${module2}/${module2}.
 ${scalarModules.map((module2) => `export type * from "./__scalar/${module2}/${module2}.document";`).join("\n")}
 
 ${databaseModules.map((module2) => {
-    const names = {
-      Module: module2.charAt(0).toUpperCase() + module2.slice(1)
-    };
-    if (module2 === "setting" || module2 === "summary")
-      return `export const ${module2}Db = dbOf("${module2}" as const, ${module2}.${names.Module}Input, ${module2}.${names.Module}, ${module2}.${names.Module}Model, ${module2}.${names.Module}Middleware, cnst.${names.Module}, cnst.${rootLib ? "root." : ""}${names.Module}Insight, cnst.${rootLib ? "root." : ""}${names.Module}Filter);`;
-    else
-      return `export const ${module2}Db = dbOf("${module2}" as const, ${module2}.${names.Module}Input, ${module2}.${names.Module}, ${module2}.${names.Module}Model, ${module2}.${names.Module}Middleware, cnst.${names.Module}, cnst.${names.Module}Insight, cnst.${names.Module}Filter, cnst.${names.Module}Summary);`;
+    const names = { Module: module2.charAt(0).toUpperCase() + module2.slice(1) };
+    return `export const ${module2}Db = dbOf("${module2}" as const, ${module2}.${names.Module}Input, ${module2}.${names.Module}, ${module2}.${names.Module}Model, ${module2}.${names.Module}Middleware, cnst.${names.Module}, cnst.${names.Module}Insight, cnst.${names.Module}Filter);`;
   }).join("\n")}
 `;
 }

package/cjs/src/templates/lib/dict.js

@@ -31,12 +31,12 @@ function getContent(scanInfo, dict = {}) {
   return `
 import { makeDictionary, makeTrans } from "@akanjs/dictionary";
 
-import { libDictionaries } from "./__lib/lib.dictionary";
+import { allLibs } from "./__lib/lib.dictionary";
 ${databaseModules.map((module2) => `import { ${module2}Dictionary } from "./${module2}/${module2}.dictionary";`).join("\n")}
 ${serviceModules.map((module2) => `import { ${module2}Dictionary } from "./_${module2}/${module2}.dictionary";`).join("\n")}
 ${scalarModules.map((module2) => `import { ${module2}Dictionary } from "./__scalar/${module2}/${module2}.dictionary";`).join("\n")}
 
-export const dictionary = makeDictionary(...libDictionaries, {
+export const dictionary = makeDictionary(...allLibs, {
   ${[...databaseModules, ...scalarModules, ...serviceModules].map((module2) => `${module2}: ${module2}Dictionary`).join(",\n  ")}
 } as const);
  

package/cjs/src/templates/lib/sig.js

@@ -26,8 +26,28 @@ var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
+  const databaseModules = [...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => module2);
+  const scalarConstantModules = [...scanInfo.scalar.entries()].filter(([_, files]) => files.has("constant")).map(([module2]) => module2);
+  const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => module2);
   return `
+import { fetchOf, gqlOf, makeFetch, scalarUtilOf } from "@akanjs/signal";
+
+import { root, libFetches } from "./__lib/lib.signal";
+import * as cnst from "./cnst";
+
+${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => `import { ${capitalize(module2)}Signal } from "./${module2}/${module2}.signal";`).join("\n")}
+${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => `import { ${capitalize(module2)}Signal } from "./_${module2}/${module2}.signal";`).join("\n")}
+
 ${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => `export { ${capitalize(module2)}Signal } from "./${module2}/${module2}.signal";`).join("\n")}
 ${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module2]) => `export { ${capitalize(module2)}Signal } from "./_${module2}/${module2}.signal";`).join("\n")}
+
+${databaseModules.map((module2) => `${["user", "setting", "summary"].includes(module2) ? "export " : ""}const ${module2}Gql = gqlOf(cnst.${module2}Cnst, ${capitalize(module2)}Signal${scanInfo.name !== "shared" && ["user", "setting", "summary"].includes(module2) ? `, { overwrite: root.${module2}Gql }` : ""});`).join("\n")}
+
+export const fetch = makeFetch(...libFetches, {
+${databaseModules.map((module2) => `...${module2}Gql,`).join("\n")}
+${scalarConstantModules.map((module2) => `...scalarUtilOf(cnst.${module2}Cnst),`).join("\n")}
+${serviceModules.map((module2) => `...fetchOf(${capitalize(module2)}Signal),`).join("\n")}
+${databaseModules.map((module2) => `${module2}Gql,`).join("\n")}
+});
 `;
 }