sonamu 0.0.42 → 0.1.2

package/src/testing/fixture-manager.ts

@@ -3,7 +3,7 @@ import knex, { Knex } from "knex";
 import { uniq } from "lodash";
 import { Sonamu } from "../api";
 import { BaseModel } from "../database/base-model";
-import { SMDManager } from "../smd/smd-manager";
+import { EntityManager } from "../entity/entity-manager";
 import {
   isBelongsToOneRelationProp,
   isOneToOneRelationProp,
@@ -160,12 +160,12 @@ export class FixtureManagerClass {
     await frdb.destroy();
   }
 
-  async importFixture(smdId: string, ids: number[]) {
+  async importFixture(entityId: string, ids: number[]) {
     const queries = uniq(
       (
         await Promise.all(
           ids.map(async (id) => {
-            return await this.getImportQueries(smdId, "id", id);
+            return await this.getImportQueries(entityId, "id", id);
           })
         )
       ).flat()
@@ -182,18 +182,18 @@ export class FixtureManagerClass {
   }
 
   async getImportQueries(
-    smdId: string,
+    entityId: string,
     field: string,
     id: number
   ): Promise<string[]> {
-    console.log({ smdId, field, id });
-    const smd = SMDManager.get(smdId);
+    console.log({ entityId, field, id });
+    const entity = EntityManager.get(entityId);
     const wdb = BaseModel.getDB("w");
 
     // 여기서 실DB의 row 가져옴
-    const [row] = await wdb(smd.table).where(field, id).limit(1);
+    const [row] = await wdb(entity.table).where(field, id).limit(1);
     if (row === undefined) {
-      throw new Error(`${smdId}#${id} row를 찾을 수 없습니다.`);
+      throw new Error(`${entityId}#${id} row를 찾을 수 없습니다.`);
     }
 
     // 픽스쳐DB, 실DB
@@ -202,9 +202,9 @@ export class FixtureManagerClass {
     const realDatabase = (Sonamu.dbConfig.production_master.connection as any)
       .database;
 
-    const selfQuery = `INSERT IGNORE INTO \`${fixtureDatabase}\`.\`${smd.table}\` (SELECT * FROM \`${realDatabase}\`.\`${smd.table}\` WHERE \`id\` = ${id})`;
+    const selfQuery = `INSERT IGNORE INTO \`${fixtureDatabase}\`.\`${entity.table}\` (SELECT * FROM \`${realDatabase}\`.\`${entity.table}\` WHERE \`id\` = ${id})`;
 
-    const args = Object.entries(smd.relations)
+    const args = Object.entries(entity.relations)
       .filter(
         ([, relation]) =>
           isBelongsToOneRelationProp(relation) ||
@@ -230,7 +230,7 @@ export class FixtureManagerClass {
           id = row[`${relation.name}_id`];
         }
         return {
-          smdId: relation.with,
+          entityId: relation.with,
           field,
           id,
         };
@@ -239,7 +239,7 @@ export class FixtureManagerClass {
 
     const relQueries = await Promise.all(
       args.map(async (args) => {
-        return this.getImportQueries(args.smdId, args.field, args.id);
+        return this.getImportQueries(args.entityId, args.field, args.id);
       })
     );
 

package/src/types/types.ts

@@ -97,14 +97,14 @@ export type TimestampProp = CommonProp & {
 };
 export type JsonProp = CommonProp & {
   type: "json";
-  as: { ref: string } | z.ZodTypeAny;
+  id: string;
 };
 export type UuidProp = CommonProp & {
   type: "uuid";
 };
 export type VirtualProp = CommonProp & {
   type: "virtual";
-  as: { ref: string } | z.ZodTypeAny;
+  id: string;
 };
 
 export type RelationType =
@@ -162,7 +162,7 @@ export type RelationProp =
   | HasManyRelationProp
   | ManyToManyRelationProp;
 
-export type SMDProp =
+export type EntityProp =
   | IntegerProp
   | BigIntegerProp
   | TextProp
@@ -181,19 +181,47 @@ export type SMDProp =
   | VirtualProp
   | RelationProp;
 
-export type SMDIndex = {
+export type EntityIndex = {
   type: "index" | "unique";
   columns: string[];
   name?: string;
 };
+export type EntityJson = {
+  id: string;
+  parentId?: string;
+  table: string;
+  title?: string;
+  props: EntityProp[];
+  indexes: EntityIndex[];
+  subsets: {
+    [subset: string]: string[];
+  };
+  enums: {
+    [enumId: string]: {
+      [key: string]: string;
+    };
+  };
+};
+export type EntitySubsetRow = {
+  field: string;
+  has: {
+    [key: string]: boolean;
+  };
+  children: EntitySubsetRow[];
+  prefixes: string[];
+  relationEntity?: string;
+  isOpen?: boolean;
+};
+export type FlattenSubsetRow = Omit<EntitySubsetRow, "children">;
 
+// SMD Legacy
 export type SMDInput<T extends string> = {
   id: string;
   parentId?: string;
   table?: string;
   title?: string;
-  props?: SMDProp[];
-  indexes?: SMDIndex[];
+  props?: EntityProp[];
+  indexes?: EntityIndex[];
   subsets?: {
     [subset: string]: T[];
   };
@@ -203,15 +231,15 @@ export type SMDInput<T extends string> = {
   PropNode
 */
 
-export type SMDPropNode =
+export type EntityPropNode =
   | {
       nodeType: "plain";
-      prop: SMDProp;
+      prop: EntityProp;
     }
   | {
       nodeType: "object" | "array";
-      prop?: SMDProp;
-      children: SMDPropNode[];
+      prop?: EntityProp;
+      children: EntityPropNode[];
     };
 
 /*
@@ -574,47 +602,41 @@ export type RenderingNode = {
 };
 
 export const TemplateOptions = z.object({
-  smd: z.object({
-    smdId: z.string(),
+  entity: z.object({
+    entityId: z.string(),
+    parentId: z.string().optional(),
     title: z.string(),
-    refCode: z.string().optional(),
-  }),
-  init_enums: z.object({
-    smdId: z.string(),
-    def: z.record(z.record(z.string())).optional(),
+    table: z.string().optional(),
   }),
   init_types: z.object({
-    smdId: z.string(),
-  }),
-  init_generated: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   generated: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   generated_http: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   model: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     defaultSearchField: z.string(),
     defaultOrderBy: z.string(),
   }),
   model_test: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   bridge: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   service: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   view_list: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     extra: z.unknown(),
   }),
   view_list_columns: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     columns: z
       .object({
         name: z.string(),
@@ -625,30 +647,30 @@ export const TemplateOptions = z.object({
     columnImports: z.string(),
   }),
   view_search_input: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   view_form: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   view_id_all_select: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
   }),
   view_id_async_select: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     textField: z.string(),
   }),
   view_enums_select: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     enumId: z.string(),
     idConstant: z.string(),
   }),
   view_enums_dropdown: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     enumId: z.string(),
     idConstant: z.string(),
   }),
   view_enums_buttonset: z.object({
-    smdId: z.string(),
+    entityId: z.string(),
     enumId: z.string(),
     idConstant: z.string(),
   }),
@@ -656,10 +678,8 @@ export const TemplateOptions = z.object({
 export type TemplateOptions = z.infer<typeof TemplateOptions>;
 
 export const TemplateKey = z.enum([
-  "smd",
-  "init_enums",
+  "entity",
   "init_types",
-  "init_generated",
   "generated",
   "generated_http",
   "model",

package/src/utils/utils.ts

@@ -46,3 +46,7 @@ export async function findApiRootPath() {
   } while (dir.split(path.sep).length > 1);
   throw new Error("Cannot find AppRoot using Sonamu -2");
 }
+
+export function nonNullable<T>(value: T): value is NonNullable<T> {
+  return value !== null && value !== undefined;
+}

package/tsconfig.json

@@ -8,7 +8,6 @@
     "lib": ["esnext", "dom"],
     "declaration": true,
     "declarationMap": true,
-    "esModuleInterop": true,
 
     /* Strict Type-Checking Options */
     "strict": true,
@@ -26,6 +25,10 @@
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
 
+    /* Module Resolution Options */
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+
     /* Experimental Options */
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,

package/src/templates/init_enums.template.ts

@@ -1,71 +0,0 @@
-import { camelize } from "inflection";
-import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
-import { Template } from "./base-template";
-
-export class Template__init_enums extends Template {
-  constructor() {
-    super("init_enums");
-  }
-
-  getTargetAndPath(names: SMDNamesRecord) {
-    return {
-      target: "api/src/application",
-      path: `${names.fs}/${names.fs}.enums.ts`,
-    };
-  }
-
-  render(options: TemplateOptions["init_enums"]) {
-    const { smdId, def } = options;
-    const names = SMDManager.getNamesFromId(smdId);
-
-    const record = def ?? {};
-    record.ORDER_BY ??= {
-      "id-desc": "최신순",
-    };
-    record.SEARCH_FIELD ??= {
-      id: "ID",
-    };
-
-    return {
-      ...this.getTargetAndPath(names),
-      body: `
-import { z } from "zod";
-import { EnumsLabelKo } from "sonamu";
-
-${Object.entries(record)
-  .map(
-    ([key, value]) => `export const ${smdId}${camelize(
-      key.toLowerCase(),
-      false
-    )} = z.enum([${Object.keys(value)
-      .map((v) => `"${v}"`)
-      .join(",")}]);
-export type ${smdId}${camelize(
-      key.toLowerCase(),
-      false
-    )} = z.infer<typeof ${smdId}${camelize(key.toLowerCase(), false)}>;`
-  )
-  .join("\n")}
-
-export namespace ${names.constant} {
-  ${Object.entries(record)
-    .map(
-      ([key, value]) => `// ${key}
-export const ${key}:EnumsLabelKo<${smdId}${camelize(
-        key.toLowerCase(),
-        false
-      )}> = {
-  ${Object.entries(value)
-    .map(([ek, ev]) => `"${ek}": { ko: "${ev}" }`)
-    .join(",")}
-};
-      `
-    )
-    .join("\n")}
-}
-      `.trim(),
-      importKeys: [],
-    };
-  }
-}

package/src/templates/init_generated.template.ts

@@ -1,51 +0,0 @@
-import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
-import { Template } from "./base-template";
-
-export class Template__init_generated extends Template {
-  constructor() {
-    super("init_generated");
-  }
-
-  getTargetAndPath(names: SMDNamesRecord) {
-    return {
-      target: "api/src/application",
-      path: `${names.fs}/${names.fs}.generated.ts`,
-    };
-  }
-
-  render({ smdId }: TemplateOptions["init_generated"]) {
-    const names = SMDManager.getNamesFromId(smdId);
-
-    return {
-      ...this.getTargetAndPath(names),
-      body: `
-import { z } from "zod";
-import { ${smdId}SearchField, ${smdId}OrderBy } from "./${names.fs}.enums";
-
-export const ${smdId}BaseSchema = z.object({});
-export type ${smdId}BaseSchema = z.infer<typeof ${smdId}BaseSchema>;
-
-export const ${smdId}BaseListParams = z.object({
-  num: z.number().int().min(0),
-  page: z.number().int().min(1),
-  search: ${smdId}SearchField,
-  keyword: z.string(),
-  orderBy: ${smdId}OrderBy,
-  withoutCount: z.boolean(),
-}).partial();
-export type ${smdId}BaseListParams = z.infer<typeof ${smdId}BaseListParams>;
-
-export type ${smdId}SubsetKey = never;
-export type ${smdId}SubsetMapping = {};
-/* BEGIN- Server-side Only */
-import { SubsetQuery } from "sonamu";
-export const ${names.camel}SubsetQueries: { [key in ${smdId}SubsetKey]: SubsetQuery } = {};
-
-export type ${smdId}FieldExpr = string;
-/* END- Server-side Only */
-      `.trim(),
-      importKeys: [],
-    };
-  }
-}

package/src/templates/smd.template.ts

@@ -1,53 +0,0 @@
-import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
-import { Template } from "./base-template";
-
-export class Template__smd extends Template {
-  constructor() {
-    super("smd");
-  }
-
-  getTargetAndPath(names: SMDNamesRecord) {
-    return {
-      target: "api/src/application",
-      path: `${names.fs}/${names.fs}.smd.ts`,
-    };
-  }
-
-  render(options: TemplateOptions["smd"]) {
-    const { smdId, title, refCode } = options;
-    const names = SMDManager.getNamesFromId(smdId);
-
-    return {
-      ...this.getTargetAndPath(names),
-      body: `
-import { p, i, SMDInput } from "sonamu";
-import { ${smdId}FieldExpr } from "./${names.fs}.generated";
-
-/*
-  ${smdId} SMD
-*/
-
-export const ${names.camel}SmdInput: SMDInput<${smdId}FieldExpr> = {
-  id: "${smdId}",
-  title: "${title ?? smdId}",
-  props: [
-    p.integer("id", { unsigned: true }),
-    p.timestamp("created_at", {
-      now: true,
-    }),
-  ],
-  indexes: [
-    i.index('created_at'),
-    //
-  ],
-  subsets: {
-    A: [ 'id', 'created_at' ]
-  }
-};
-${refCode ? `\n/* REFERENCE\n\n${refCode}\n*/` : ""}
-`.trim(),
-      importKeys: [],
-    };
-  }
-}