@akanjs/cli 0.0.34 → 0.0.35

package/templates/module/__Model__.Util.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Model_Util_exports = {};
+__export(Model_Util_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(Model_Util_exports);
+function getContent(scanResult, dict) {
+  return `
+"use client";
+import { ModelDashboardProps, ModelInsightProps } from "@akanjs/client";
+import { getQueryMap } from "@akanjs/constant";
+import { cnst } from "@${dict.appName}/client";
+import { Data } from "@shared/ui";
+
+export const Stat = ({
+  className,
+  summary,
+  sliceName = "${dict.model}",
+  queryMap = getQueryMap(cnst.${dict.Model}Summary),
+  hidePresents,
+}: ModelDashboardProps<cnst.Summary>) => {
+  return (
+    <Data.Dashboard
+      className={className}
+      summary={summary}
+      sliceName={sliceName}
+      queryMap={queryMap}
+      columns={["total${dict.Model}"]}
+      hidePresents={hidePresents}
+    />
+  );
+};
+
+export const Insight = ({
+  className,
+  insight,
+  sliceName = "${dict.model}",
+}: ModelInsightProps<cnst.${dict.Model}Insight>) => {
+  return (
+    <Data.Insight
+      className={className}
+      insight={insight}
+      sliceName={sliceName}
+      columns={["count"]}
+    />
+  );
+};
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__Model__.View.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Model_View_exports = {};
+__export(Model_View_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(Model_View_exports);
+function getContent(scanResult, dict = {}) {
+  return `
+import { clsx } from "@akanjs/client";
+import { cnst } from "@${dict.appName}/client";
+import { Image } from "@util/ui";
+
+interface ${dict.Model}ViewProps {
+  className?: string;
+  ${dict.model}: cnst.${dict.Model};
+  self?: { id?: string } | null;
+}
+
+export const General = ({ className, ${dict.model}, self }: ${dict.Model}ViewProps) => {
+  return (
+    <div className={clsx(className, "animate-fadeIn w-full")}>
+      <div>{${dict.model}.id}</div>
+    </div>
+  );
+};
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__Model__.Zone.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Model_Zone_exports = {};
+__export(Model_Zone_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(Model_Zone_exports);
+function getContent(scanResult, dict) {
+  return `
+"use client";
+import { Data, Load } from "@shared/ui";
+import { ModelsProps } from "@akanjs/client";
+import { cnst, ${dict.Model} } from "@${dict.appName}/client";
+import { ClientInit, ClientView, DefaultOf } from "@akanjs/signal";
+
+export const Admin = ({ sliceName = "${dict.model}", init, query }: ModelsProps<cnst.${dict.Model}>>) => {
+  return (
+    <Data.ListContainer
+      init={init}
+      query={query}
+      sliceName={sliceName}
+      renderItem={${dict.Model}.Unit.Card}
+      renderDashboard={${dict.Model}.Util.Stat}
+      renderInsight={${dict.Model}.Util.Insight}
+      renderTemplate={${dict.Model}.Template.General}
+      renderTitle={(${dict.model}: DefaultOf<cnst.${dict.Model}>>) => \`${dict.Model} - \${${dict.model}.id ? ${dict.model}.id : "New"}\`}
+      renderView={(${dict.model}: cnst.${dict.Model}>) => <${dict.Model}.View.General ${dict.model}={${dict.model}} />}
+      columns={[
+        "id",
+        "status",
+        "createdAt",
+        "updatedAt",
+      ]}
+      actions={(${dict.model}: cnst.Light${dict.Model}, idx) => ["remove", "edit", "view"]}
+    />
+  );
+};
+
+interface CardProps {
+  className?: string;
+  init: ClientInit<"${dict.model}", cnst.Light${dict.Model}>;
+}
+export const Card = ({ className, init }: CardProps) => {
+  return (
+    <Load.Units
+      className={className}
+      init={init}
+      renderItem={(${dict.model}: cnst.Light${dict.Model}) => (
+        <${dict.Model}.Unit.Card key={${dict.model}.id} href={\`/${dict.model}/\${${dict.model}.id}\`} ${dict.model}={${dict.model}} />
+      )}
+    />
+  );
+};
+
+interface ViewProps {
+  className?: string;
+  view: ClientView<"${dict.model}", cnst.${dict.Model}>;
+}
+export const View = ({ view }: ViewProps) => {
+  return <Load.View view={view} renderView={(${dict.model}) => <${dict.Model}.View.General ${dict.model}={${dict.model}} />} />;
+};
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__model__.constant.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_constant_exports = {};
+__export(model_constant_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_constant_exports);
+function getContent(scanResult, dict) {
+  return `
+import { enumOf, Int } from "@akanjs/base";
+import { Field, Filter, Model, sortOf, 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;
+}
+
+@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;
+}
+
+@Model.Light("Light${dict.Model}")
+export class Light${dict.Model} extends via(${dict.Model}Object, [
+  "field",
+  "status",
+] as const) {}
+
+@Model.Full("${dict.Model}")
+export class ${dict.Model} extends via(${dict.Model}Object, Light${dict.Model}) {}
+
+@Model.Insight("${dict.Model}Insight")
+export class ${dict.Model}Insight {
+  @Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
+  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}, {}) {}
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__model__.dictionary.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_dictionary_exports = {};
+__export(model_dictionary_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_dictionary_exports);
+function getContent(scanResult, dict) {
+  return `
+import {
+  baseTrans,
+  getBaseSignalTrans,
+  ModelDictionary,
+  SignalDictionary,
+  SummaryDictionary,
+} 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";
+
+const modelDictionary = {
+  ...baseTrans,
+  modelName: ["${dict.Model}", "${dict.Model}"],
+  modelDesc: [
+    "${dict.Model} description",
+    "${dict.Model} \uC124\uBA85",
+  ],
+
+  // * ==================== Model ==================== * //
+  field: ["Field", "\uD544\uB4DC"],
+  "desc-field": ["Field", "\uD544\uB4DC"],
+  // * ==================== Model ==================== * //
+
+  // * ==================== Insight ==================== * //
+  count: ["Count", "\uAC1C\uC218"],
+  "desc-count": ["${dict.Model} count in current query settting", "\uD604\uC7AC \uCFFC\uB9AC \uC124\uC815\uC5D0 \uB9DE\uB294 \uBC30\uB108 \uC218"],
+  // * ==================== Insight ==================== * //
+
+  // * ==================== Filter ==================== * //
+  // * ==================== Filter ==================== * //
+
+  // * ==================== Etc ==================== * //
+  "enum-status-active": ["Active", "\uD65C\uC131"],
+  "enumdesc-status-active": ["Active status", "\uD65C\uC131 \uC0C1\uD0DC"],
+  // * ==================== Etc ==================== * //
+} satisfies ModelDictionary<${dict.Model}, ${dict.Model}Insight, ${dict.Model}Filter>;
+
+export const ${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 ==================== * //
+  "api-${dict.model}ListInPublic": ["${dict.Model} List In Public", "\uACF5\uAC1C\uB41C ${dict.Model} \uB9AC\uC2A4\uD2B8"],
+  "apidesc-${dict.model}ListInPublic": ["Get a list of public ${dict.model}", "\uACF5\uAC1C\uB41C ${dict.Model}\uC758 \uB9AC\uC2A4\uD2B8\uB97C \uAC00\uC838\uC635\uB2C8\uB2E4"],
+  "arg-${dict.model}ListInPublic-statuses": ["Statuses", "\uC0C1\uD0DC"],
+  "argdesc-${dict.model}ListInPublic-statuses": ["Statuses to filter", "\uD544\uD130\uB9C1\uD560 \uC0C1\uD0DC"],
+  "arg-${dict.model}ListInPublic-skip": ["Skip", "\uAC74\uB108\uB6F0\uAE30"],
+  "argdesc-${dict.model}ListInPublic-skip": ["Number of items to skip", "\uAC74\uB108\uB6F8 \uC544\uC774\uD15C \uC218"],
+  "arg-${dict.model}ListInPublic-limit": ["Limit", "\uC81C\uD55C"],
+  "argdesc-${dict.model}ListInPublic-limit": ["Maximum number of items to return", "\uBC18\uD658\uD560 \uCD5C\uB300 \uC544\uC774\uD15C \uC218"],
+  "arg-${dict.model}ListInPublic-sort": ["Sort", "\uC815\uB82C"],
+  "argdesc-${dict.model}ListInPublic-sort": ["Sort order of the items", "\uC544\uC774\uD15C\uC758 \uC815\uB82C \uC21C\uC11C"],
+
+  "api-${dict.model}InsightInPublic": ["${dict.Model} Insight In Public", "\uACF5\uAC1C\uB41C ${dict.Model} \uC778\uC0AC\uC774\uD2B8"],
+  "apidesc-${dict.model}InsightInPublic": [
+    "Get insight data for public ${dict.model}",
+    "\uACF5\uAC1C\uB41C ${dict.Model}\uC5D0 \uB300\uD55C \uC778\uC0AC\uC774\uD2B8 \uB370\uC774\uD130\uB97C \uAC00\uC838\uC635\uB2C8\uB2E4",
+  ],
+  "arg-${dict.model}InsightInPublic-statuses": ["Statuses", "\uC0C1\uD0DC"],
+  "argdesc-${dict.model}InsightInPublic-statuses": ["Statuses to filter", "\uD544\uD130\uB9C1\uD560 \uC0C1\uD0DC"],
+  // * ==================== Endpoint ==================== * //
+} satisfies SignalDictionary<${dict.Model}Signal, ${dict.Model}>;
+
+export const ${dict.model}Dictionary = { ...modelDictionary, ...signalDictionary };
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__model__.document.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_document_exports = {};
+__export(model_document_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_document_exports);
+function getContent(scanResult, dict) {
+  return `
+import { beyond, by, Database, into, type SchemaOf } from "@akanjs/document";
+
+import { 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) {
+  async getSummary(): Promise<cnst.${dict.Model}Summary> {
+    return {
+      ...(await this.getDefaultSummary()),
+    };
+  }
+}
+
+@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 })
+  }
+}
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__model__.service.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_service_exports = {};
+__export(model_service_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_service_exports);
+function getContent(scanResult, dict) {
+  return `
+import { DbService, Service } from "@akanjs/service";
+
+import { cnst } from "../cnst";
+import * as db from "../db";
+
+@Service("${dict.Model}Service")
+export class ${dict.Model}Service extends DbService(db.${dict.Model}Db) {
+  async summarize(): Promise<cnst.${dict.Model}Summary> {
+    return {
+      ...(await this.${dict.Model}Model.getSummary()),
+    };
+  }
+}
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__model__.signal.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_signal_exports = {};
+__export(model_signal_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_signal_exports);
+function getContent(scanResult, dict) {
+  return `
+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";
+
+@Signal(() => cnst.${dict.Model})
+export class ${dict.Model}Signal extends DbSignal(cnst.${dict.model}Cnst, Srvs, {
+  guards: { get: Query.Public, cru: Mutation.Public },
+}) {
+  // * /////////////////////////////////////
+  // * Public Slice
+  @Query.Public(() => [cnst.${dict.Model}])
+  async ${dict.model}ListInPublic(
+    @Arg.Query("statuses", () => [String], { nullable: true }) statuses: cnst.${dict.Model}Status[] | null,
+    @Arg.Query("skip", () => Int, { nullable: true }) skip: number | null,
+    @Arg.Query("limit", () => Int, { nullable: true }) limit: number | null,
+    @Arg.Query("sort", () => String, { nullable: true }) sort: SortOf<cnst.${dict.Model}Filter> | null
+  ) {
+    const ${dict.models} = await this.${dict.model}Service.listByStatuses(statuses, { skip, limit, sort });
+    return resolve<cnst.${dict.Model}[]>(${dict.models});
+  }
+  @Query.Public(() => cnst.${dict.Model}Insight)
+  async ${dict.model}InsightInPublic(
+    @Arg.Query("statuses", () => [String], { nullable: true }) statuses: cnst.${dict.Model}Status[] | null
+  ) {
+    const ${dict.model}Insight = await this.${dict.model}Service.insightByStatuses(statuses);
+    return resolve<cnst.${dict.Model}Insight>(${dict.model}Insight);
+  }
+  // * Public Slice
+  // * /////////////////////////////////////
+}
+`;
+}
+module.exports = module.exports.default;

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

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_signal_spec_exports = {};
+__export(model_signal_spec_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_signal_spec_exports);
+function getContent(scanResult, dict) {
+  return `
+import * as adminSpec from "@shared/lib/admin/admin.signal.spec";
+import * as userSpec from "@${dict.appName}/lib/user/user.signal.spec";
+import { cnst } from "../cnst";
+import { fetch } from "../fetch";
+import { sampleOf } from "@akanjs/test";
+
+export const create${dict.Model} = async (adminAgent: userSpec.AdminAgent, userAgent: userSpec.UserAgent) => {
+  const ${dict.model}Input = sampleOf(cnst.${dict.Model}Input);
+  const ${dict.model} = await adminAgent.fetch.create${dict.Model}(${dict.model}Input);
+  return ${dict.model};
+};
+`;
+}
+module.exports = module.exports.default;

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

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_signal_test_exports = {};
+__export(model_signal_test_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_signal_test_exports);
+function getContent(scanResult, dict) {
+  return `
+import * as adminSpec from "@shared/lib/admin/admin.signal.spec";
+import * as userSpec from "@${dict.appName}/lib/user/user.signal.spec";
+import * as ${dict.model}Spec from "@${dict.appName}/lib/${dict.model}/${dict.model}.signal.spec";
+import { cnst } from "../cnst";
+import { fetch } from "../fetch";
+
+describe("${dict.Model} Signal", () => {
+  describe("${dict.Model} Service", () => {
+    let adminAgent: userSpec.AdminAgent;
+    let userAgent: userSpec.UserAgent;
+    let ${dict.model}: cnst.${dict.Model};
+    beforeAll(async () => {
+      // adminAgent = await adminSpec.getAdminAgentWithInitialize();
+      // userAgent = await userSpec.getUserAgentWithPhone();
+    });
+    it("can create ${dict.model}", async () => {
+      // ${dict.model} = await ${dict.model}Spec.create${dict.Model}(adminAgent, userAgent);
+    });
+  });
+});
+`;
+}
+module.exports = module.exports.default;

package/templates/module/__model__.store.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_store_exports = {};
+__export(model_store_exports, {
+  default: () => getContent
+});
+module.exports = __toCommonJS(model_store_exports);
+function getContent(scanResult, dict) {
+  return `
+import { stateOf, Store } from "@akanjs/store";
+
+import { cnst } from "../cnst";
+import { fetch } from "../fetch";
+
+@Store(() => cnst.${dict.Model})
+export class ${dict.Model}Store extends stateOf(fetch.${dict.model}Gql, {
+  // state
+}) {
+  // action
+}
+`;
+}
+module.exports = module.exports.default;