@akanjs/cli 1.0.19 → 2.1.0-rc.0

package/templates/env/_env.server.type.ts

@@ -0,0 +1,16 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const libs = scanInfo.getLibs();
+  return {
+    filename: "env.server.type.ts",
+    content: `
+${libs.length ? libs.map((lib) => `import { env as ${lib}Option } from "@libs/${lib}/server";`).join("\n") : 'import { getEnv } from "akanjs/base";'}
+
+export const libEnv = {
+${libs.length ? libs.map((lib) => `  ...${lib}Option,`).join("\n") : "  ...getEnv(),"}
+};
+`,
+  };
+}

package/templates/facetIndex/index.ts

@@ -0,0 +1,33 @@
+import type { AppInfo, LibInfo } from "akanjs";
+import type { SysExecutor } from "@akanjs/devkit";
+
+interface Dict {
+  [key: string]: string;
+}
+
+interface Options {
+  exec?: SysExecutor;
+  facet?: string;
+}
+
+const sourceFilePattern = /\.(ts|tsx)$/;
+const excludedFilePattern = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
+
+export default async function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict = {}, options: Options = {}) {
+  const { exec, facet } = options;
+  if (!exec || !facet || !(await exec.exists(facet))) return null;
+
+  const { files, dirs } = await exec.getFilesAndDirs(facet);
+  const exportNames = [
+    ...files
+      .filter((filename) => sourceFilePattern.test(filename) && !excludedFilePattern.test(filename))
+      .map((filename) => filename.replace(sourceFilePattern, "")),
+    ...dirs.filter((dirname) => !dirname.startsWith(".")),
+  ].sort();
+
+  if (exportNames.length === 0) return null;
+  return {
+    filename: "index.ts",
+    content: `${exportNames.map((name) => `export * from "./${name}";`).join("\n")}\n`,
+  };
+}

package/templates/index.ts

@@ -0,0 +1,10 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+interface Dict {
+  [key: string]: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict = {}) {
+  return `
+export * as cnst from "./lib/cnst";
+`;
+}

package/templates/lib/__lib/lib.constant.ts

@@ -0,0 +1,38 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const libs = scanInfo.getLibs();
+  const libInfos = scanInfo.getLibInfos();
+  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),
+          ] as [string, string[]],
+      )
+      .filter(([_, libNames]) => libNames.length > 0),
+  );
+  return `
+${libs.map((lib) => `import { cnst as ${lib} } from "@libs/${lib}";`).join("\n")}
+
+${Object.entries(extendedModels)
+  .map(([modelName, extendedModels]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  inputs: [${extendedModels.map((libName) => `${libName}.${ModelName}Input`).join(", ")}] as const,
+  objects: [${extendedModels.map((libName) => `${libName}.${ModelName}Object`).join(", ")}] as const,
+  lights: [${extendedModels.map((libName) => `${libName}.Light${ModelName}`).join(", ")}] as const,
+  models: [${extendedModels.map((libName) => `${libName}.${ModelName}`).join(", ")}] as const,
+  insights: [${extendedModels.map((libName) => `${libName}.${ModelName}Insight`).join(", ")}] as const,
+}`;
+  })
+  .join("\n")}
+`;
+}

package/templates/lib/__lib/lib.dictionary.ts

@@ -0,0 +1,33 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const libs = scanInfo.getLibs();
+  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),
+          ] as [string, string[]],
+      )
+      .filter(([_, libNames]) => libNames.length > 0),
+  );
+  return `
+${libs.map((lib) => `import { dict as ${lib} } from "@libs/${lib}/server";`).join("\n")}
+
+${Object.entries(extendedModels)
+  .map(([modelName, extendedModels]) => {
+    return `export const ${modelName} = {
+  dictionaries: [${extendedModels.map((libName) => `${libName}.${modelName}.dictionary`).join(", ")}] as const,
+};`;
+  })
+  .join("\n")}
+`;
+}

package/templates/lib/__lib/lib.document.ts

@@ -0,0 +1,35 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const libs = scanInfo.getLibs();
+  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),
+          ] as [string, string[]],
+      )
+      .filter(([_, libNames]) => libNames.length > 0),
+  );
+  return `
+${libs.map((lib) => `import { db as ${lib} } from "@libs/${lib}/server";`).join("\n")}
+
+${Object.entries(extendedModels)
+  .map(
+    ([modelName, extendedModels]) =>
+      `export const ${modelName} = {
+  inputs: [${extendedModels.map((libName) => `${libName}.${modelName}.input`).join(", ")}] as const,
+  docs: [${extendedModels.map((libName) => `${libName}.${modelName}.doc`).join(", ")}] as const,
+  models: [${extendedModels.map((libName) => `${libName}.${modelName}.model`).join(", ")}] as const,
+  filters: [${extendedModels.map((libName) => `${libName}.${modelName}.filter`).join(", ")}] as const,
+}`,
+  )
+  .join("\n")}
+`;
+}

package/templates/lib/__lib/lib.service.ts

@@ -0,0 +1,33 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const libs = scanInfo.getLibs();
+  const libInfos = [...scanInfo.getLibInfos().values()];
+  const extendedModels = Object.fromEntries(
+    [...scanInfo.file.service.databases]
+      .map(
+        (modelName) =>
+          [
+            modelName,
+            libInfos.filter((libInfo) => libInfo.file.service.databases.has(modelName)).map((libInfo) => libInfo.name),
+          ] as [string, string[]],
+      )
+      .filter(([_, libNames]) => libNames.length > 0),
+  );
+
+  return `
+${libs.map((lib) => `import { srv as ${lib} } from "@libs/${lib}/server";`).join("\n")}
+
+${Object.entries(extendedModels)
+  .map(([modelName, extendedModels]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  services: [${extendedModels.map((libName) => `${libName}.${ModelName}Service`).join(", ")}] as const,
+}`;
+  })
+  .join("\n")}
+`;
+}

package/templates/lib/__lib/lib.signal.ts

@@ -0,0 +1,34 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const libs = scanInfo.getLibs();
+  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),
+          ] as [string, string[]],
+      )
+      .filter(([_, libNames]) => libNames.length > 0),
+  );
+  return `
+${libs.map((lib) => `import { sig as ${lib} } from "@libs/${lib}/server";`).join("\n")}
+
+${Object.entries(extendedModels)
+  .map(([modelName, extendedModels]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  internals: [${extendedModels.map((libName) => `${libName}.${ModelName}Internal`).join(", ")}] as const,
+  slices: [${extendedModels.map((libName) => `${libName}.${ModelName}Slice`).join(", ")}] as const,
+  endpoints: [${extendedModels.map((libName) => `${libName}.${ModelName}Endpoint`).join(", ")}] as const,
+}`;
+  })
+  .join("\n")}
+`;
+}

package/templates/lib/__lib/lib.store.ts

@@ -0,0 +1,33 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  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),
+          ] as [string, string[]],
+      )
+      .filter(([_, libNames]) => libNames.length > 0),
+  );
+  return `
+import * as base from "akanjs/store";
+${libs.map((lib) => `import { store as ${lib} } from "@libs/${lib}/client";`).join("\n")}
+
+${Object.entries(extendedModels)
+  .map(([modelName, extendedModels]) => {
+    const ModelName = capitalize(modelName);
+    return `export const ${modelName} = {
+  stores: [${extendedModels.map((libName) => `${libName}.${ModelName}Store`).join(", ")}] as const,
+}`;
+  })
+  .join("\n")}
+`;
+}

package/templates/lib/cnst.ts

@@ -0,0 +1,29 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const databaseModules = scanInfo.getDatabaseModules();
+  const scalarModules = scanInfo.getScalarModules();
+  const libs = scanInfo.getLibs();
+  const libInfos = scanInfo.getLibInfos();
+  return `
+import { ConstantRegistry } from "akanjs/constant";
+${scalarModules.map((module) => `import * as ${module}Cnst from "./__scalar/${module}/${module}.constant";`).join("\n")}
+${databaseModules.map((module) => `import * as ${module}Cnst from "./${module}/${module}.constant";`).join("\n")}
+
+${libs.map((lib) => `export { cnst as ${lib} } from "@libs/${lib}";`).join("\n")}
+
+${scalarModules.map((module) => `export * from "./__scalar/${module}/${module}.constant";`).join("\n")}
+${databaseModules.map((module) => `export * from "./${module}/${module}.constant";`).join("\n")}
+
+${databaseModules
+  .map((module) => {
+    const names = { Module: capitalize(module) };
+    return `export const ${module} = ConstantRegistry.buildModel("${module}" as const, ${module}Cnst.${names.Module}Input, ${module}Cnst.${names.Module}Object, ${module}Cnst.${names.Module}, ${module}Cnst.Light${names.Module}, ${module}Cnst.${names.Module}Insight, ${module}Cnst);`;
+  })
+  .join("\n")}
+${scalarModules.map((module) => `export const ${module} = ConstantRegistry.buildScalar("${module}" as const, ${module}Cnst.${capitalize(module)}, ${module}Cnst);`).join("\n")}
+`;
+}

package/templates/lib/db.ts

@@ -0,0 +1,32 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const databaseModules = scanInfo.getDatabaseModules();
+  const scalarModules = scanInfo.getScalarModules();
+  const libs = scanInfo.getLibs();
+  return `
+import { ${databaseModules.length ? "by, " : ""}DatabaseRegistry } from "akanjs/document";
+${scalarModules.map((module) => `import { ${capitalize(module)} } from "./__scalar/${module}/${module}.document";`).join("\n")}
+${databaseModules.length ? `import * as cnst from "./cnst";` : ""}
+${databaseModules.map((module) => `import * as ${module}Db from "./${module}/${module}.document";`).join("\n")}
+
+${libs.map((lib) => `export { db as ${lib} } from "@libs/${lib}/server";`).join("\n")}
+
+${databaseModules.map((module) => `class ${capitalize(module)}Input extends by(cnst.${capitalize(module)}Input) {}`).join("\n")}
+${databaseModules.length ? `export type { ${databaseModules.map((module) => `${capitalize(module)}Input`).join(", ")} };` : ""}
+
+${scalarModules.map((module) => `export type * from "./__scalar/${module}/${module}.document";`).join("\n")}
+${databaseModules.map((module) => `export type * from "./${module}/${module}.document";`).join("\n")}
+
+${databaseModules
+  .map((module) => {
+    const names = { Module: module.charAt(0).toUpperCase() + module.slice(1) };
+    return `export const ${module} = DatabaseRegistry.buildModel("${module}" as const, ${names.Module}Input, ${module}Db.${names.Module}, ${module}Db.${names.Module}Model, cnst.${names.Module}, cnst.${names.Module}Insight, ${module}Db.${names.Module}Filter);`;
+  })
+  .join("\n")}
+${scalarModules.map((module) => `export const ${module} = DatabaseRegistry.buildScalar("${module}" as const, ${capitalize(module)});`).join("\n")}
+`;
+}

package/{esm/src/templates/lib/dict.js → templates/lib/dict.ts}

@@ -1,15 +1,16 @@
-// pkgs/@akanjs/cli/src/templates/lib/dict.ts
-var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
-function getContent(scanInfo, dict = {}) {
-  if (!scanInfo)
-    return null;
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
   const databaseModules = scanInfo.getDatabaseModules();
   const scalarModules = scanInfo.getScalarModules();
   const serviceModules = scanInfo.getServiceModules();
+  const libs = scanInfo.getLibs();
   return `
-import { makeDictionary, makeTrans, registerScalarTrans, registerServiceTrans, registerModelTrans } from "@akanjs/dictionary";
+import { makeDictionary, makeTrans, registerScalarTrans, registerServiceTrans, registerModelTrans${libs.length === 0 ? `, dictionary as base` : ""} } from "akanjs/dictionary";
+${libs.length ? libs.map((lib) => `import { dictionary as ${lib} } from "@libs/${lib}/server";`).join("\n") : ""}
 
-import { allLibs } from "./__lib/lib.dictionary";
 ${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")}
@@ -26,24 +27,23 @@ ${databaseModules.map((module) => `import type * as ${module}Doc from "./${modul
 ${databaseModules.map((module) => `import type * as ${module}Sig from "./${module}/${module}.signal";`).join("\n")}
 ${serviceModules.map((module) => `import type * as ${module}Sig from "./_${module}/${module}.signal";`).join("\n")}
 
-export const dictionary = makeDictionary(...allLibs, {
+export const dictionary = makeDictionary(${libs.length ? libs.join(", ") : "base"}, {
   ${[
     ...databaseModules.map((module) => {
       const Module = capitalize(module);
-      return `${module}: registerModelTrans<"${module}", ${module}Cnst.${Module}, ${module}Cnst.${Module}Insight, ${module}Doc.${Module}Filter, ${module}Sig.${Module}Slice, ${module}Sig.${Module}Endpoint, typeof ${module}.dictionary>(${module}.dictionary)`;
+      return `${module}: registerModelTrans<"${module}", ${module}Cnst.${Module}, ${module}Cnst.${Module}Insight, ${module}Doc.${Module}Filter, ${module}Sig.${Module}Slice, ${module}Sig.${Module}Endpoint, any>(${module}.dictionary.applyBaseSignal("${module}" as const) as any)`;
     }),
     ...scalarModules.map(
-      (module) => `${module}: registerScalarTrans<"${module}", ${module}Cnst.${capitalize(module)}, typeof ${module}.dictionary>(${module}.dictionary)`
+      (module) =>
+        `${module}: registerScalarTrans<"${module}", ${module}Cnst.${capitalize(module)}, typeof ${module}.dictionary>(${module}.dictionary)`,
     ),
     ...serviceModules.map(
-      (module) => `${module}: registerServiceTrans<"${module}", ${module}Sig.${capitalize(module)}Endpoint, typeof ${module}.dictionary>(${module}.dictionary)`
-    )
+      (module) =>
+        `${module}: registerServiceTrans<"${module}", ${module}Sig.${capitalize(module)}Endpoint, typeof ${module}.dictionary>(${module}.dictionary)`,
+    ),
   ].join(",\n  ")}
 });
  
-export const { Revert, translate, msg, __Dict_Key__, __Error_Key__ } = makeTrans(dictionary);
+export const { Err, translate, msg, getAllDictionary, __Dict_Key__, __Error_Key__ } = makeTrans(dictionary);
 `;
 }
-export {
-  getContent as default
-};

package/templates/lib/sig.ts

@@ -0,0 +1,60 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  const databaseModules = [...scanInfo.database.entries()]
+    .filter(([_, files]) => files.has("signal"))
+    .map(([module]) => module);
+  const serviceModules = [...scanInfo.service.entries()]
+    .filter(([_, files]) => files.has("signal"))
+    .map(([module]) => module);
+  const libs = scanInfo.getLibs();
+
+  return `
+import { FetchClient } from "akanjs/fetch";
+import { SignalRegistry, serverSignal${libs.length === 0 ? ", fetch as base" : ""} } from "akanjs/signal";
+${libs.map((lib) => `import { fetch as ${lib} } from "@libs/${lib}/server";`).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 * from "./${module}/${module}.signal";`)
+  .join("\n")}
+${[...scanInfo.service.entries()]
+  .filter(([_, files]) => files.has("signal"))
+  .map(([module]) => `export * from "./_${module}/${module}.signal";`)
+  .join("\n")}
+
+${[...scanInfo.database.entries()]
+  .filter(([_, files]) => files.has("signal"))
+  .map(
+    ([module]) =>
+      `export class ${capitalize(module)} extends serverSignal(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal) {}`,
+  )
+  .join("\n")}
+${[...scanInfo.service.entries()]
+  .filter(([_, files]) => files.has("signal"))
+  .map(
+    ([module]) =>
+      `export class ${capitalize(module)} extends serverSignal(${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Internal) {}`,
+  )
+  .join("\n")}
+
+${databaseModules.map((module) => `export const ${module} = SignalRegistry.registerDatabase("${module}" as const, ${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Endpoint, ${module}Sig.${capitalize(module)}Slice, ${capitalize(module)});`).join("\n")}
+${serviceModules.map((module) => `export const ${module} = SignalRegistry.registerService("${module}" as const, ${module}Sig.${capitalize(module)}Internal, ${module}Sig.${capitalize(module)}Endpoint, ${capitalize(module)});`).join("\n")}
+
+export const fetch = FetchClient.from(${[...(libs.length === 0 ? ["base"] : libs), ...databaseModules, ...serviceModules].join(", ")});
+
+export const getSerializedSignal = () => fetch.serializedSignal
+`;
+}

package/templates/lib/srv.ts

@@ -0,0 +1,34 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  if (!scanInfo) return null;
+  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);
+  const libs = scanInfo.getLibs();
+  return `
+import { ServiceModel } from "akanjs/service";
+${libs.length ? libs.map((lib) => `import { option as ${lib} } from "@libs/${lib}/server";`).join("\n") : 'import type { BackendEnv } from "akanjs/base";'}
+
+import * as cnst from "./cnst";
+import * as db from "./db";
+
+${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")}
+
+${libs.map((lib) => `export { srv as ${lib} } from "@libs/${lib}/server";`).join("\n")}
+
+${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")}
+
+${databaseModules.map((module) => `export const ${module} = ServiceModel.fromModel(${capitalize(module)}Service, cnst.${module}, db.${module});`).join("\n")}
+${serviceModules.map((module) => `export const ${module} = ServiceModel.from(${capitalize(module)}Service);`).join("\n")}
+
+export type LibOptions = ${libs.length ? libs.map((lib) => `${lib}.ModulesOptions`).join(" & ") : "BackendEnv"};
+`;
+}

package/templates/lib/st.ts

@@ -0,0 +1,31 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  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);
+  const libs = scanInfo.getLibs();
+  return `
+import { ${libs.length === 0 ? "RootStore as base, " : ""}StoreRegistry } from "akanjs/store";
+${libs.map((lib) => `import { RootStore as ${lib} } from "@libs/${lib}/client";`).join("\n")}
+
+${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")}
+
+${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} = StoreRegistry.register(${capitalize(module)}Store);`).join("\n")}
+${serviceModules.map((module) => `export const ${module} = StoreRegistry.register(${capitalize(module)}Store);`).join("\n")}
+
+export class RootStore extends StoreRegistry.merge("${scanInfo.name}" as const, ${[...(libs.length === 0 ? ["base"] : libs), ...databaseModules, ...serviceModules].join(",\n  ")}) {}
+  
+export const st = StoreRegistry.build(RootStore);
+`;
+}

package/templates/lib/useClient.ts

@@ -0,0 +1,19 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  return `
+import { makePageProto, registerClientRuntime } from "akanjs/client";
+import { FetchClient } from "akanjs/fetch";
+import * as cnst from "./cnst";
+import { getAllDictionary } from "./dict" with { type: "macro" };
+import type * as dict from "./dict";
+import { getSerializedSignal } from "./sig" with { type: "macro" };
+import type * as signal from "./sig";
+
+const pageProto = makePageProto<typeof dict>(getAllDictionary());
+const fetchProto = FetchClient.build<typeof signal>(cnst, getSerializedSignal(), { Err: pageProto.Err });
+export const runtime = registerClientRuntime({ ...pageProto, ...fetchProto }, { scope: ${JSON.stringify(scanInfo?.type ?? "lib")} });
+
+export const { msg, Err, usePage, sig, fetch } = runtime;
+`;
+}

package/templates/lib/useServer.ts

@@ -0,0 +1,7 @@
+import type { AppInfo, LibInfo } from "akanjs";
+
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: { [key: string]: string } = {}) {
+  return `
+export { fetch } from "./sig";
+`;
+}

package/templates/libRoot/akan.config.ts

@@ -0,0 +1,12 @@
+interface Dict {
+  libName: string;
+}
+export default function getContent(scanInfo: null, dict: Dict) {
+  return `
+import type { LibConfig } from "akanjs";
+
+const config: LibConfig = {};
+
+export default config;
+  `;
+}

package/templates/libRoot/base/baseLogic.ts

@@ -0,0 +1,14 @@
+interface Dict {
+  libName: string;
+}
+export default function getContent(scanInfo: null, dict: Dict) {
+  return `
+// 현 디렉토리에서는 프로젝트 내 전체적으로 사용되는 로직을 구현하며, 따라서 백/프론트 비의존적인 pure js 코드만 구현 가능합니다.
+// common폴더와 다른점은, base 코드는 시스템 전체에서 import되어 사용되므로, 가장 핵심적인 로직과 추상화된 기능만 구현해야합니다.
+// @${dict.libName}/base에서는 서버/클라이언트 관련 라이브러리(@*/server, @*/server, @*/client, @*/client)를 모두 import할 수 없으며, @*/base 라이브러리만 import 가능합니다.
+
+export const someBaseLogic = () => {
+  //
+};
+  `;
+}

package/templates/libRoot/base/index.ts

@@ -0,0 +1,8 @@
+interface Dict {
+  [key: string]: string;
+}
+export default function getContent(scanInfo: null, dict: Dict = {}) {
+  return `
+export * from "./baseLogic";
+  `;
+}

package/templates/libRoot/common/commonLogic.ts

@@ -0,0 +1,14 @@
+interface Dict {
+  libName: string;
+}
+export default function getContent(scanInfo: null, dict: Dict) {
+  return `
+// 현 디렉토리에서는 프로젝트 내 전체적으로 사용되는 세부적인 로직을 구현하며, 따라서 백/프론트 비의존적인 pure js 코드만 구현 가능합니다.
+// base폴더와 다른점은, common 코드는 사용하는 파일에서만 import되기 때문에, 외부라이브러리를 import해서 사용하거나 상세한 로직을 구현할 수 있습니다.
+// @${dict.libName}/common에서는 서버/클라이언트 관련 라이브러리(@*/server, @*/server, @*/client, @*/client)를 모두 import할 수 없으며, @*/base와 @*/common 라이브러리만 import 가능합니다.
+
+export const someCommonLogic = () => {
+  //
+};
+  `;
+}

package/templates/libRoot/common/index.ts

@@ -0,0 +1,8 @@
+interface Dict {
+  [key: string]: string;
+}
+export default function getContent(scanInfo: null, dict: Dict = {}) {
+  return `
+export * from "./commonLogic";
+  `;
+}

package/{esm/src/templates/libRoot/lib/___libName__/__libName__.dictionary.js → templates/libRoot/lib/___libName__/__libName__.dictionary.ts}

@@ -1,7 +1,10 @@
-// pkgs/@akanjs/cli/src/templates/libRoot/lib/___libName__/__libName__.dictionary.ts
-function getContent(scanInfo, dict) {
+interface Dict {
+  libName: string;
+  LibName: string;
+}
+export default function getContent(scanInfo: null, dict: Dict) {
   return `
-import { serviceDictionary } from "@akanjs/dictionary";
+import { serviceDictionary } from "akanjs/dictionary";
 
 import type { ${dict.LibName}Endpoint } from "./${dict.libName}.signal";
 
@@ -10,6 +13,3 @@ export const dictionary = serviceDictionary(["en", "ko"])
   .translate({});
 `;
 }
-export {
-  getContent as default
-};