@akanjs/cli 0.9.43 → 0.9.45

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()),
-    };
-  }
-${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")}
+});
 `;
 }

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

@@ -22,15 +22,27 @@ __export(st_exports, {
   default: () => getContent
 });
 module.exports = __toCommonJS(st_exports);
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
+  const databaseModules = [...scanInfo.database.entries()].filter(([_, fileTypes]) => fileTypes.has("store")).map(([key]) => key);
+  const serviceModules = [...scanInfo.service.entries()].filter(([_, fileTypes]) => fileTypes.has("store")).map(([key]) => key);
   return `
 "use client";
 import { makeStore, st as baseSt } from "@akanjs/store";
+import { MixStore, rootStoreOf } from "@akanjs/store";
 
-import { store } from "./store";
+import { libStores } from "./__lib/lib.store";
+${databaseModules.map((module2) => `import { ${capitalize(module2)}Store } from "./${module2}/${module2}.store";`).join("\n")}
+${serviceModules.map((module2) => `import { ${capitalize(module2)}Store } from "./_${module2}/${module2}.store";`).join("\n")}
 
+export class RootStore extends MixStore(
+  ...libStores,
+  ${[...databaseModules, ...serviceModules].map((module2) => `${capitalize(module2)}Store`).join(",\n  ")}
+) {}
+  
+export const store = rootStoreOf(RootStore);
 export const st = makeStore(baseSt, store${scanInfo.type === "lib" ? `, { library: true }` : ""});
 `;
 }

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

@@ -26,8 +26,8 @@ function getContent(scanInfo, dict = {}) {
   return `
 import { makePageProto } from "@akanjs/next";
 
-import { dictionary } from "./dict";
+import type { dictionary } from "./dict";
 
-export const usePage = makePageProto([dictionary]);
+export const { msg, Revert, usePage } = makePageProto<typeof dictionary>();
 `;
 }

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

@@ -54,12 +54,6 @@ export class ${dict.Model}Insight {
   count: number;
 }
 
-@Model.Summary("${dict.Model}Summary")
-export class ${dict.Model}Summary {
-  @Field.Prop(() => Int, { min: 0, default: 0, query: {} })
-  total${dict.Model}: number;
-}
-
 @Model.Filter("${dict.Model}Filter")
 export class ${dict.Model}Filter extends sortOf(${dict.Model}, {}) {
   @Filter.Mongo()

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

@@ -24,13 +24,7 @@ __export(model_dictionary_exports, {
 module.exports = __toCommonJS(model_dictionary_exports);
 function getContent(scanInfo, dict) {
   return `
-import {
-  baseTrans,
-  getBaseSignalTrans,
-  ModelDictionary,
-  SignalDictionary,
-  SummaryDictionary,
-} from "@akanjs/dictionary";
+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";
@@ -66,13 +60,6 @@ const modelDictionary = {
   // * ==================== Etc ==================== * //
 } satisfies ModelDictionary<${dict.Model}, ${dict.Model}Insight, ${dict.Model}Filter>;
 
-export const ${dict.model}SummaryDictionary = {
-  // * ==================== Summary ==================== * //
-  total${dict.Model}: ["Total${dict.Model}", "\uCD1D \uBC30\uB108 \uC218"],
-  "desc-total${dict.Model}": ["Total ${dict.model} count in the database", "\uB370\uC774\uD130\uBCA0\uC774\uC2A4\uC5D0 \uC800\uC7A5\uB41C \uCD1D \uBC30\uB108 \uC218"],
-  // * ==================== Summary ==================== * //
-} satisfies SummaryDictionary<${dict.Model}Summary>;
-
 const signalDictionary = {
   ...getBaseSignalTrans("${dict.model}" as const),
   // * ==================== Endpoint ==================== * //

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

@@ -26,7 +26,7 @@ function getContent(scanInfo, dict) {
   return `
 import { beyond, by, Database, into, type SchemaOf } from "@akanjs/document";
 
-import { cnst } from "../cnst";
+import * as cnst from "../cnst";
 
 @Database.Input(() => cnst.${dict.Model}Input)
 export class ${dict.Model}Input extends by(cnst.${dict.Model}Input) {}

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

@@ -26,7 +26,7 @@ function getContent(scanInfo, dict) {
   return `
 import { DbService, Service } from "@akanjs/service";
 
-import { cnst } from "../cnst";
+import * as cnst from "../cnst";
 import * as db from "../db";
 
 @Service("${dict.Model}Service")

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

@@ -28,10 +28,10 @@ import { Int } from "@akanjs/base";
 import { SortOf } from "@akanjs/constant";
 import { Arg, DbSignal, Mutation, Query, resolve, Signal } from "@akanjs/signal";
 
-import { cnst, Srvs } from "../cnst";
+import * as cnst from "../cnst";
 
 @Signal(() => cnst.${dict.Model})
-export class ${dict.Model}Signal extends DbSignal(cnst.${dict.model}Cnst, Srvs, {
+export class ${dict.Model}Signal extends DbSignal(cnst.${dict.model}Cnst, cnst.Srvs, {
   guards: { get: Query.Public, cru: Mutation.Public },
 }) {
   // * /////////////////////////////////////

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

@@ -26,8 +26,8 @@ function getContent(scanInfo, dict) {
   return `
 import * as adminSpec from "@shared/lib/admin/admin.signal.spec";
 import * as userSpec from "@${dict.sysName}/lib/user/user.signal.spec";
-import { cnst } from "../cnst";
-import { fetch } from "../fetch";
+import * as cnst from "../cnst";
+import { fetch } from "../sig";
 import { sampleOf } from "@akanjs/test";
 
 export const create${dict.Model} = async (adminAgent: userSpec.AdminAgent, userAgent: userSpec.UserAgent) => {

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

@@ -27,8 +27,8 @@ function getContent(scanInfo, dict) {
 import * as adminSpec from "@shared/lib/admin/admin.signal.spec";
 import * as userSpec from "@${dict.sysName}/lib/user/user.signal.spec";
 import * as ${dict.model}Spec from "@${dict.sysName}/lib/${dict.model}/${dict.model}.signal.spec";
-import { cnst } from "../cnst";
-import { fetch } from "../fetch";
+import * as cnst from "../cnst";
+import { fetch } from "../sig";
 
 describe("${dict.Model} Signal", () => {
   describe("${dict.Model} Service", () => {

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

@@ -26,8 +26,8 @@ function getContent(scanInfo, dict) {
   return `
 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.${dict.Model})
 export class ${dict.Model}Store extends stateOf(fetch.${dict.model}Gql, {

package/cjs/src/templates/server.js

@@ -36,7 +36,7 @@ ${libs.map((lib) => `import { registerModules as register${capitalize(lib)}Modul
   
 import * as db from "./lib/db";
 import { allSrvs } from "./lib/srv";
-import { cnst } from "./lib/cnst";
+import * as cnst from "./lib/cnst";
 import * as srv from "./lib/srv";
 import * as sig from "./lib/sig";
 import { type ModulesOptions, registerGlobalModule } from "./lib/option";
@@ -71,7 +71,8 @@ export { env } from "./env/env.server.testing";
 export * as db from "./lib/db";
 export * as srv from "./lib/srv";
 export * as option from "./lib/option";
-export { cnst } from "./lib/cnst";
-export { fetch } from "./lib/fetch";
+export * as cnst from "./lib/cnst";
+export { fetch } from "./lib/sig";
+export * from "./lib/dict";
 `;
 }

package/cjs/src/templates/workspaceRoot/.gitignore.template

@@ -85,27 +85,21 @@ local.properties
 apps/**/lib/__lib/**
 libs/**/lib/__lib/**
 apps/*/lib/cnst.ts
-apps/*/lib/cnst_.ts
 apps/*/lib/dict.ts
 apps/*/lib/db.ts
-apps/*/lib/fetch.ts
 apps/*/lib/srv.ts
 apps/*/lib/st.ts
 apps/*/lib/sig.ts
-apps/*/lib/store.ts
 apps/*/lib/usePage.ts
 apps/*/lib/*/index.tsx
 apps/*/client.ts
 apps/*/server.ts
 libs/*/lib/cnst.ts
-libs/*/lib/cnst_.ts
 libs/*/lib/dict.ts
 libs/*/lib/db.ts
-libs/*/lib/fetch.ts
 libs/*/lib/srv.ts
 libs/*/lib/st.ts
 libs/*/lib/sig.ts
-libs/*/lib/store.ts
 libs/*/lib/usePage.ts
 apps/*/lib/*/index.tsx
 libs/*/client.ts