@akanjs/cli 0.9.48 → 0.9.49

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

@@ -14,14 +14,17 @@ function getContent(scanInfo, dict = {}) {
     ).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}/server";`).join("\n")}
+${libs.length === 0 ? `import * as base from "@akanjs/dictionary";` : ""}
+${libs.map((lib) => `import { dict as ${lib} } from "@${lib}/server";`).join("\n")}
 
 ${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
-    return `export const ${modelName} = Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}`).join(", ")});`;
+    return `export const ${modelName} = {
+  models: Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}.modelDictionary`).join(", ")}),
+  signals: Object.assign({}, ${extendedModels2.map((libName) => `${libName}.${modelName}.signalDictionary`).join(", ")}),
+};`;
   }).join("\n")}
 
-export const allLibs = [${libs.length === 0 ? "base" : libs.join(", ")}] as const;
+export const allLibs = [${libs.length === 0 ? "base.dictionary" : libs.map((lib) => `${lib}.dictionary`).join(", ")}] as const;
 `;
 }
 export {

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

@@ -18,9 +18,10 @@ ${libs.map((lib) => `export { db as ${lib} } from "@${lib}/server";`).join("\n")
 
 ${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,
+  inputs: [${extendedModels2.map((libName) => `${libName}.${modelName}.Input`).join(", ")}] as const,
+  docs: [${extendedModels2.map((libName) => `${libName}.${modelName}.Doc`).join(", ")}] as const,
+  models: [${extendedModels2.map((libName) => `${libName}.${modelName}.Model`).join(", ")}] as const,
+  filters: [${extendedModels2.map((libName) => `${libName}.${modelName}.Filter`).join(", ")}] as const,
 }`
   ).join("\n")}
 export const allLibs = [${libs.join(", ")}] as const;

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

@@ -14,7 +14,7 @@ function getContent(scanInfo, dict = {}) {
     ).filter(([_, libNames]) => libNames.length > 0)
   );
   return `
-${libs.length ? `import { DbService, Srv } from "@akanjs/service";` : `import type { BackendEnv } from "@akanjs/base";`}
+${libs.length ? `import { serve, 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";

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

@@ -1,15 +1,34 @@
 // pkgs/@akanjs/cli/src/templates/lib/__lib/lib.signal.ts
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 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.signal.databases].map(
+      (modelName) => [
+        modelName,
+        libInfos.filter((libInfo) => libInfo.file.signal.databases.has(modelName)).map((libInfo) => libInfo.name)
+      ]
+    ).filter(([_, libNames]) => libNames.length > 0)
+  );
   return `
-${libs.length > 0 ? "" : `import { fetch as base } from "@akanjs/signal";`}
-${libs.map((lib) => `import { fetch as ${lib} } from "@${lib}";`).join("\n")}
+${libs.length > 0 ? "" : `import { fetch as baseFetch } from "@akanjs/signal";`}
+${libs.map((lib) => `import { sig as ${lib} } from "@${lib}/server";`).join("\n")}
 
-export const root = ${libs.length ? rootLib ?? libs[0] : "base"};
-export const libFetches = [${libs.length ? libs.join(", ") : "base"}] as const;
+${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  internals: [${extendedModels2.map((libName) => `${libName}.${ModelName}Internal`).join(", ")}] as const,
+  slices: [${extendedModels2.map((libName) => `${libName}.${ModelName}Slice`).join(", ")}] as const,
+  endpoints: [${extendedModels2.map((libName) => `${libName}.${ModelName}Endpoint`).join(", ")}] as const,
+}`;
+  }).join("\n")}
+
+export const root = ${libs.length ? rootLib ?? libs[0] : "baseFetch"};
+export const libFetches = [${libs.length ? libs.map((lib) => `${lib}.fetch`).join(", ") : "baseFetch"}] as const;
 `;
 }
 export {

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

@@ -1,13 +1,30 @@
 // pkgs/@akanjs/cli/src/templates/lib/__lib/lib.store.ts
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 function getContent(scanInfo, dict = {}) {
   if (!scanInfo)
     return null;
   const libs = scanInfo.getLibs();
+  const libInfos = [...scanInfo.getLibInfos().values()];
+  const extendedModels = Object.fromEntries(
+    [...scanInfo.file.store.databases].map(
+      (modelName) => [
+        modelName,
+        libInfos.filter((libInfo) => libInfo.file.store.databases.has(modelName)).map((libInfo) => libInfo.name)
+      ]
+    ).filter(([_, libNames]) => libNames.length > 0)
+  );
   return `
-import { store as base } from "@akanjs/store";
+import * as base from "@akanjs/store";
 ${libs.map((lib) => `import { store as ${lib} } from "@${lib}/client";`).join("\n")}
 
-export const libStores = [${[...libs, "base"].join(", ")}] as const;
+${Object.entries(extendedModels).map(([modelName, extendedModels2]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  stores: [${extendedModels2.map((libName) => `${libName}.${ModelName}Store`).join(", ")}] as const,
+}`;
+  }).join("\n")}
+
+export const libStores = [${[...libs, "base"].map((lib) => `${lib}.RootStore`).join(", ")}] as const;
 `;
 }
 export {

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

@@ -5,11 +5,19 @@ function getContent(scanInfo, dict = {}) {
     return null;
   const databaseModules = scanInfo.getDatabaseModules();
   const scalarModules = scanInfo.getScalarModules();
+  const libInfos = scanInfo.getLibInfos();
+  const extendedModelMap = new Map(
+    [...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 `
-import type { AllSrvs } from "./srv";
 import { cnstOf, scalarCnstOf } from "@akanjs/constant";
 
-${databaseModules.map((module) => `import * as ${module} from "./${module}/${module}.constant";`).join("\n")}
+${databaseModules.map((module) => `import * as ${module}Cnst from "./${module}/${module}.constant";`).join("\n")}
 ${scalarModules.map((module) => `import { ${capitalize(module)} } from "./__scalar/${module}/${module}.constant";`).join("\n")}
 
 export * from "./__lib/lib.constant";
@@ -18,11 +26,9 @@ ${scalarModules.map((module) => `export * from "./__scalar/${module}/${module}.c
 
 ${databaseModules.map((module) => {
     const names = { Module: capitalize(module) };
-    return `export const ${module}Cnst = cnstOf("${module}" as const, ${module}.${names.Module}Input, ${module}.${names.Module}, ${module}.Light${names.Module}, ${module}.${names.Module}Insight, ${module}.${names.Module}Filter);`;
+    return `export const ${module} = cnstOf("${module}" as const, ${module}Cnst.${names.Module}Input, ${module}Cnst.${names.Module}, ${module}Cnst.Light${names.Module}, ${module}Cnst.${names.Module}Insight${extendedModelMap.has(module) ? ", { overwrite: true }" : ""});`;
   }).join("\n")}
-${scalarModules.map((module) => `export const ${module}Cnst = scalarCnstOf("${module}" as const, ${capitalize(module)});`).join("\n")}
-
-export const Srvs = {} as AllSrvs;
+${scalarModules.map((module) => `export const ${module} = scalarCnstOf("${module}" as const, ${capitalize(module)});`).join("\n")}
 `;
 }
 export {

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

@@ -1,24 +1,31 @@
 // pkgs/@akanjs/cli/src/templates/lib/db.ts
+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 { dbOf } from "@akanjs/document";
+import { by, dbOf, scalarDbOf } from "@akanjs/document";
 
 import * as cnst from "./cnst";
 
-${databaseModules.map((module) => `import * as ${module} from "./${module}/${module}.document";`).join("\n")}
+${databaseModules.map((module) => `import * as ${module}Db from "./${module}/${module}.document";`).join("\n")}
+${scalarModules.map((module) => `import { ${capitalize(module)} } from "./__scalar/${module}/${module}.document";`).join("\n")}
+
+${databaseModules.map((module) => `class ${capitalize(module)}Input extends by(cnst.${capitalize(module)}Input) {}`).join("\n")}
+export type { ${databaseModules.map((module) => `${capitalize(module)}Input`).join(", ")} };
 
 export type * from "./__lib/lib.document";
+
 ${databaseModules.map((module) => `export type * from "./${module}/${module}.document";`).join("\n")}
 ${scalarModules.map((module) => `export type * from "./__scalar/${module}/${module}.document";`).join("\n")}
 
 ${databaseModules.map((module) => {
     const names = { Module: module.charAt(0).toUpperCase() + module.slice(1) };
-    return `export const ${module}Db = dbOf("${module}" as const, ${module}.${names.Module}Input, ${module}.${names.Module}, ${module}.${names.Module}Model, ${module}.${names.Module}Middleware, cnst.${names.Module}, cnst.${names.Module}Insight, cnst.${names.Module}Filter);`;
+    return `export const ${module} = dbOf("${module}" as const, ${names.Module}Input, ${module}Db.${names.Module}, ${module}Db.${names.Module}Model, ${module}Db.${names.Module}Middleware, cnst.${names.Module}, cnst.${names.Module}Insight, ${module}Db.${names.Module}Filter);`;
   }).join("\n")}
+${scalarModules.map((module) => `export const ${module} = scalarDbOf("${module}" as const, ${capitalize(module)});`).join("\n")}
 `;
 }
 export {

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

@@ -9,12 +9,20 @@ function getContent(scanInfo, dict = {}) {
 import { makeDictionary, makeTrans } from "@akanjs/dictionary";
 
 import { allLibs } from "./__lib/lib.dictionary";
-${databaseModules.map((module) => `import { ${module}Dictionary } from "./${module}/${module}.dictionary";`).join("\n")}
-${serviceModules.map((module) => `import { ${module}Dictionary } from "./_${module}/${module}.dictionary";`).join("\n")}
-${scalarModules.map((module) => `import { ${module}Dictionary } from "./__scalar/${module}/${module}.dictionary";`).join("\n")}
+${databaseModules.map((module) => `import * as ${module} from "./${module}/${module}.dictionary";`).join("\n")}
+${serviceModules.map((module) => `import * as ${module} from "./_${module}/${module}.dictionary";`).join("\n")}
+${scalarModules.map((module) => `import * as ${module} from "./__scalar/${module}/${module}.dictionary";`).join("\n")}
+
+${databaseModules.map((module) => `export * as ${module} from "./${module}/${module}.dictionary";`).join("\n")}
+${serviceModules.map((module) => `export * as ${module} from "./_${module}/${module}.dictionary";`).join("\n")}
+${scalarModules.map((module) => `export * as ${module} from "./__scalar/${module}/${module}.dictionary";`).join("\n")}
 
 export const dictionary = makeDictionary(...allLibs, {
-  ${[...databaseModules, ...scalarModules, ...serviceModules].map((module) => `${module}: ${module}Dictionary`).join(",\n  ")}
+  ${[
+    ...databaseModules.map((module) => `${module}: { ...${module}.modelDictionary, ...${module}.signalDictionary }`),
+    ...scalarModules.map((module) => `${module}: ${module}.dictionary`),
+    ...serviceModules.map((module) => `${module}: ${module}.dictionary`)
+  ].join(",\n  ")}
 } as const);
  
 export const { Revert, translate, msg } = makeTrans(dictionary);

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

@@ -7,24 +7,35 @@ function getContent(scanInfo, dict = {}) {
   const scalarConstantModules = [...scanInfo.scalar.entries()].filter(([_, files]) => files.has("constant")).map(([module]) => module);
   const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => module);
   return `
-import { fetchOf, gqlOf, makeFetch, scalarUtilOf } from "@akanjs/signal";
+import { fetchOf, gqlOf, makeFetch, mergeSignals, signalInfo } from "@akanjs/signal";
 
 import { root, libFetches } from "./__lib/lib.signal";
 import * as cnst from "./cnst";
+import * as db from "./db";
 
-${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `import { ${capitalize(module)}Signal } from "./${module}/${module}.signal";`).join("\n")}
-${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `import { ${capitalize(module)}Signal } from "./_${module}/${module}.signal";`).join("\n")}
+${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `import * as ${module}Sig from "./${module}/${module}.signal";`).join("\n")}
+${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `import * as ${module}Sig from "./_${module}/${module}.signal";`).join("\n")}
 
-${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `export { ${capitalize(module)}Signal } from "./${module}/${module}.signal";`).join("\n")}
-${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `export { ${capitalize(module)}Signal } from "./_${module}/${module}.signal";`).join("\n")}
+${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `export * from "./${module}/${module}.signal";`).join("\n")}
+${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(([module]) => `export * from "./_${module}/${module}.signal";`).join("\n")}
 
-${databaseModules.map((module) => `${["user", "setting", "summary"].includes(module) ? "export " : ""}const ${module}Gql = gqlOf(cnst.${module}Cnst, ${capitalize(module)}Signal${scanInfo.name !== "shared" && ["user", "setting", "summary"].includes(module) ? `, { overwrite: root.${module}Gql }` : ""});`).join("\n")}
+${[...scanInfo.database.entries()].filter(([_, files]) => files.has("signal")).map(
+    ([module]) => `export class ${capitalize(module)}Signal extends mergeSignals(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Slice) {}`
+  ).join("\n")}
+${[...scanInfo.service.entries()].filter(([_, files]) => files.has("signal")).map(
+    ([module]) => `export const ${capitalize(module)}Signal = mergeSignals(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal);`
+  ).join("\n")}
+
+const signals = signalInfo.registerSignals(
+${[...databaseModules, ...serviceModules].map((module) => `  ${capitalize(module)}Signal,`).join("\n")}
+);
+export const serializedSignals = signals.map((signal) => signalInfo.serialize(signal));
+
+${databaseModules.map((module) => `export const ${module} = gqlOf(cnst.${module}, db.${module}.Filter, ${capitalize(module)}Signal${scanInfo.name !== "shared" && ["user", "setting", "summary"].includes(module) ? `, { overwrite: root.${module} }` : ""});`).join("\n")}
 
 export const fetch = makeFetch(...libFetches, {
-${databaseModules.map((module) => `...${module}Gql,`).join("\n")}
-${scalarConstantModules.map((module) => `...scalarUtilOf(cnst.${module}Cnst),`).join("\n")}
+${databaseModules.map((module) => `...${module},`).join("\n")}
 ${serviceModules.map((module) => `...fetchOf(${capitalize(module)}Signal),`).join("\n")}
-${databaseModules.map((module) => `${module}Gql,`).join("\n")}
 });
 `;
 }

package/esm/src/templates/lib/srv.js

@@ -6,8 +6,9 @@ function getContent(scanInfo, dict = {}) {
   const databaseModules = [...scanInfo.database.entries()].filter(([_, files]) => files.has("service")).map(([module]) => module);
   const serviceModules = [...scanInfo.service.entries()].filter(([_, files]) => files.has("service")).map(([module]) => module);
   return `
-import { GetServices } from "@akanjs/service";
+import { GetServices, ServiceModule, serviceInfo } from "@akanjs/service";
 
+import * as cnst from "./cnst";
 import { libAllSrvs } from "./__lib/lib.service";
 ${databaseModules.map((module) => `import { ${capitalize(module)}Service } from "./${module}/${module}.service";`).join("\n")}
 ${serviceModules.map((module) => `import { ${capitalize(module)}Service } from "./_${module}/${module}.service";`).join("\n")}
@@ -16,12 +17,12 @@ export * from "./__lib/lib.service";
 ${databaseModules.map((module) => `export { ${capitalize(module)}Service } from "./${module}/${module}.service";`).join("\n")}
 ${serviceModules.map((module) => `export { ${capitalize(module)}Service } from "./_${module}/${module}.service";`).join("\n")}
 
-export const allSrvs = {
-  ...libAllSrvs,
+export const srvs = serviceInfo.registerServices({
   ${[...databaseModules, ...serviceModules].map((module) => `${capitalize(module)}Service`).join(",\n  ")}
-} as const;
-
-export type AllSrvs = GetServices<typeof allSrvs>;
+});
+export const allSrvs = { ...libAllSrvs, ...srvs } as const;
+${databaseModules.map((module) => `export const ${module} = new ServiceModule("${module}" as const, { ${capitalize(module)}Service }, cnst.${module});`).join("\n")}
+${serviceModules.map((module) => `export const ${module} = new ServiceModule("${module}" as const, { ${capitalize(module)}Service });`).join("\n")}
 `;
 }
 export {

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

@@ -7,20 +7,22 @@ function getContent(scanInfo, dict = {}) {
   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 { st as baseSt, StoreOf } from "@akanjs/store";
+import { MixStore, storeInfo } from "@akanjs/store";
 
 import { libStores } from "./__lib/lib.store";
 ${databaseModules.map((module) => `import { ${capitalize(module)}Store } from "./${module}/${module}.store";`).join("\n")}
 ${serviceModules.map((module) => `import { ${capitalize(module)}Store } from "./_${module}/${module}.store";`).join("\n")}
 
-export class RootStore extends MixStore(
-  ...libStores,
-  ${[...databaseModules, ...serviceModules].map((module) => `${capitalize(module)}Store`).join(",\n  ")}
-) {}
+${databaseModules.map((module) => `export { ${capitalize(module)}Store } from "./${module}/${module}.store";`).join("\n")}
+${serviceModules.map((module) => `export { ${capitalize(module)}Store } from "./_${module}/${module}.store";`).join("\n")}
+
+${databaseModules.map((module) => `export const ${module} = storeInfo.register("${module}" as const, ${capitalize(module)}Store);`).join("\n")}
+${serviceModules.map((module) => `export const ${module} = storeInfo.register("${module}" as const, ${capitalize(module)}Store);`).join("\n")}
+
+export class RootStore extends MixStore(...libStores, ${[...databaseModules, ...serviceModules].join(",\n  ")}) {}
   
-export const store = rootStoreOf(RootStore);
-export const st = makeStore(baseSt, store${scanInfo.type === "lib" ? `, { library: true }` : ""});
+export const st = baseSt as StoreOf<RootStore>;
 `;
 }
 export {

package/esm/src/templates/lib/useClient.js

@@ -0,0 +1,19 @@
+// pkgs/@akanjs/cli/src/templates/lib/useClient.ts
+function getContent(scanInfo, dict = {}) {
+  return `
+import { makePageProto } from "@akanjs/client";
+import type * as signal from "./sig";
+import * as cnst from "./cnst";
+
+import type { dictionary } from "./dict";
+
+export const { msg, Revert, usePage, sig, fetch, registerClient } = makePageProto<
+  typeof dictionary,
+  typeof signal.fetch,
+  typeof signal
+>(cnst);
+`;
+}
+export {
+  getContent as default
+};

package/esm/src/templates/lib/useServer.js

@@ -0,0 +1,11 @@
+// pkgs/@akanjs/cli/src/templates/lib/useServer.ts
+function getContent(scanInfo, dict = {}) {
+  return `
+import type { fetch as sigFetch } from "./sig";
+
+export const fetch = global.fetch as unknown as typeof sigFetch;
+`;
+}
+export {
+  getContent as default
+};

package/esm/src/templates/libRoot/lib/___libName__/__libName__.service.js

@@ -1,12 +1,11 @@
 // pkgs/@akanjs/cli/src/templates/libRoot/lib/___libName__/__libName__.service.ts
 function getContent(scanInfo, dict) {
   return `
-import { LogService, Service } from "@akanjs/service";
+import { serve } from "@akanjs/service";
 
 // import type * as srv from "../srv";
 
-@Service("${dict.libName}Service", { serverMode: "batch" })
-export class ${dict.LibName}Service extends LogService("${dict.libName}Service") {}
+export class ${dict.LibName}Service extends serve("${dict.libName}" as const, { serverMode: "batch" }) {}
   `;
 }
 export {

package/esm/src/templates/libRoot/lib/___libName__/__libName__.store.js

@@ -1,10 +1,9 @@
 // pkgs/@akanjs/cli/src/templates/libRoot/lib/___libName__/__libName__.store.ts
 function getContent(scanInfo, dict) {
   return `
-import { scalarStateOf, Store } from "@akanjs/store";
+import { store } from "@akanjs/store";
 
-@Store({ name: "${dict.libName}" })
-export class ${dict.LibName}Store extends scalarStateOf("${dict.libName}" as const, {
+export class ${dict.LibName}Store extends store("${dict.libName}" as const, {
   // state
 }) {
   // action

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

@@ -2,44 +2,24 @@
 function getContent(scanInfo, dict) {
   return `
 import { enumOf, Int } from "@akanjs/base";
-import { Field, Filter, Model, sortOf, via } from "@akanjs/constant";
+import { via } from "@akanjs/constant";
 
 export const ${dict.Model}Status = enumOf(["active"] as const);
 export type ${dict.Model}Status = enumOf<typeof ${dict.Model}Status>;
 
-@Model.Input("${dict.Model}Input")
-export class ${dict.Model}Input {
-  @Field.Prop(() => String, { nullable: true })
-  field: string | null;
-}
+export class ${dict.Model}Input extends via((field) => ({
+  field: field(String).optional(),
+})) {}
 
-@Model.Object("${dict.Model}Object")
-export class ${dict.Model}Object extends via(${dict.Model}Input) {
-  @Field.Prop(() => String, { enum: ${dict.Model}Status, default: "active" })
-  status: ${dict.Model}Status;
-}
+export class ${dict.Model}Object extends via(${dict.Model}Input, (field) => ({
+  status: field(${dict.Model}Status, { default: "active" }),
+})) {}
 
-@Model.Light("Light${dict.Model}")
-export class Light${dict.Model} extends via(${dict.Model}Object, ["status"] as const) {}
+export class Light${dict.Model} extends via(${dict.Model}Object, ["status"] as const, (resolve) => ({})) {}
 
-@Model.Full("${dict.Model}")
-export class ${dict.Model} extends via(${dict.Model}Object, Light${dict.Model}) {}
+export class ${dict.Model} extends via(${dict.Model}Object, Light${dict.Model}, (resolve) => ({})) {}
 
-@Model.Insight("${dict.Model}Insight")
-export class ${dict.Model}Insight {
-  @Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
-  count: number;
-}
-
-@Model.Filter("${dict.Model}Filter")
-export class ${dict.Model}Filter extends sortOf(${dict.Model}, {}) {
-  @Filter.Mongo()
-  inStatus(
-    @Filter.Arg("status", () => String) status: ${dict.Model}Status,
-  ) {
-    return { status };
-  }
-}
+export class ${dict.Model}Insight extends via(${dict.Model}, (field) => ({})) {}
 `;
 }
 export {

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

@@ -6,7 +6,7 @@ import { baseTrans, getBaseSignalTrans, ModelDictionary, SignalDictionary } from
 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";
 
-const modelDictionary = {
+export const modelDictionary = {
   ...baseTrans,
   modelName: ["${dict.Model}", "${dict.Model}"],
   modelDesc: [
@@ -37,7 +37,7 @@ const modelDictionary = {
   // * ==================== Etc ==================== * //
 } satisfies ModelDictionary<${dict.Model}, ${dict.Model}Insight, ${dict.Model}Filter>;
 
-const signalDictionary = {
+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"],

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

@@ -1,20 +1,14 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.document.ts
 function getContent(scanInfo, dict) {
   return `
-import { beyond, by, Database, into, type SchemaOf } from "@akanjs/document";
+import { beyond, by, into, type SchemaOf } from "@akanjs/document";
 
 import * as cnst from "../cnst";
 
-@Database.Input(() => cnst.${dict.Model}Input)
-export class ${dict.Model}Input extends by(cnst.${dict.Model}Input) {}
-
-@Database.Document(() => cnst.${dict.Model})
 export class ${dict.Model} extends by(cnst.${dict.Model}) {}
 
-@Database.Model(() => cnst.${dict.Model})
-export class ${dict.Model}Model extends into(${dict.Model}, cnst.${dict.model}Cnst) {}
+export class ${dict.Model}Model extends into(${dict.Model}, cnst.${dict.model}) {}
 
-@Database.Middleware(() => cnst.${dict.Model})
 export class ${dict.Model}Middleware extends beyond(${dict.Model}Model, ${dict.Model}) {
   onSchema(schema: SchemaOf<${dict.Model}Model, ${dict.Model}>) {
     // schema.index({ status: 1 })

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

@@ -1,13 +1,12 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.service.ts
 function getContent(scanInfo, dict) {
   return `
-import { DbService, Service } from "@akanjs/service";
+import { serve } from "@akanjs/service";
 
 import * as cnst from "../cnst";
 import * as db from "../db";
 
-@Service("${dict.Model}Service")
-export class ${dict.Model}Service extends DbService(db.${dict.model}Db) {}
+export class ${dict.Model}Service extends serve(db.${dict.model}) {}
 `;
 }
 export {

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

@@ -2,14 +2,13 @@
 function getContent(scanInfo, dict) {
   return `
 import { Int } from "@akanjs/base";
-import { SortOf } from "@akanjs/constant";
-import { Arg, DbSignal, Mutation, Query, resolve, Signal } from "@akanjs/signal";
+import type { SortOf } from "@akanjs/document";
+import { Arg, signal, Mutation, Query, resolve } from "@akanjs/signal";
 
 import * as cnst from "../cnst";
 
-@Signal(() => cnst.${dict.Model})
-export class ${dict.Model}Signal extends DbSignal(cnst.${dict.model}Cnst, cnst.Srvs, {
-  guards: { get: Query.Public, cru: Mutation.Public },
+export class ${dict.Model}Signal extends signal(cnst.${dict.model}, cnst.Srvs, {
+  guards: { get: "Public", cru: "Public },
 }) {
   // * /////////////////////////////////////
   // * Public Slice

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

@@ -1,13 +1,12 @@
 // pkgs/@akanjs/cli/src/templates/module/__model__.store.ts
 function getContent(scanInfo, dict) {
   return `
-import { stateOf, Store } from "@akanjs/store";
+import { store } from "@akanjs/store";
 
 import * as cnst from "../cnst";
-import { fetch } from "../sig";
+import { fetch, sig } from "../useClient";
 
-@Store(() => cnst.${dict.Model})
-export class ${dict.Model}Store extends stateOf(fetch.${dict.model}Gql, {
+export class ${dict.Model}Store extends store(sig.${dict.model}, {
   // state
 }) {
   // action

package/esm/src/templates/server.js

@@ -11,17 +11,17 @@ function getContent(scanInfo, dict = {}) {
 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 * as db from "./lib/db";
-import { allSrvs } from "./lib/srv";
 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";
 
 // database modules
 ${databaseModules.map(([model]) => {
     const Model = capitalize(model);
-    return `const register${Model}Module = () => databaseModuleOf({ constant: cnst.${model}Cnst, database: db.${model}Db, signal: sig.${Model}Signal, service: srv.${Model}Service }, allSrvs);`;
+    return `const register${Model}Module = () => databaseModuleOf({ constant: cnst.${model}, database: db.${model}, signal: sig.${Model}Signal, service: srv.${Model}Service }, allSrvs);`;
   }).join("\n")}
 
 // service modules
@@ -47,10 +47,11 @@ ${databaseModules.map(([model]) => `    register${capitalize(model)}Module(),`).
 export { env } from "./env/env.server.testing";
 export * as db from "./lib/db";
 export * as srv from "./lib/srv";
+export * as sig from "./lib/sig";
 export * as option from "./lib/option";
 export * as cnst from "./lib/cnst";
 export { fetch } from "./lib/sig";
-export * from "./lib/dict";
+export * as dict from "./lib/dict";
 `;
 }
 export {

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

@@ -90,7 +90,8 @@ apps/*/lib/db.ts
 apps/*/lib/srv.ts
 apps/*/lib/st.ts
 apps/*/lib/sig.ts
-apps/*/lib/usePage.ts
+apps/*/lib/useClient.ts
+apps/*/lib/useServer.ts
 apps/*/lib/*/index.tsx
 apps/*/client.ts
 apps/*/server.ts
@@ -100,8 +101,9 @@ libs/*/lib/db.ts
 libs/*/lib/srv.ts
 libs/*/lib/st.ts
 libs/*/lib/sig.ts
-libs/*/lib/usePage.ts
-apps/*/lib/*/index.tsx
+libs/*/lib/useClient.ts
+libs/*/lib/useServer.ts
+libs/*/lib/*/index.tsx
 libs/*/client.ts
 libs/*/server.ts
 libs/*/index.ts

package/package.json

@@ -2,7 +2,7 @@
   "type": "module",
   "sourceType": "module",
   "name": "@akanjs/cli",
-  "version": "0.9.48",
+  "version": "0.9.49",
   "bin": {
     "akan": "esm/index.js"
   },