sonamu 0.3.1 → 0.4.2

package/src/types/types.ts

@@ -1,4 +1,3 @@
-import { Knex } from "knex";
 import { z } from "zod";
 
 /* 
@@ -90,7 +89,7 @@ export type DateProp = CommonProp & {
   type: "date";
 };
 export type DateTimeProp = CommonProp & {
-  type: "dateTime";
+  type: "datetime";
 };
 export type TimeProp = CommonProp & {
   type: "time";
@@ -279,7 +278,7 @@ export function isDateProp(p: any): p is DateProp {
   return p?.type === "date";
 }
 export function isDateTimeProp(p: any): p is DateTimeProp {
-  return p?.type === "dateTime";
+  return p?.type === "datetime";
 }
 export function isTimeProp(p: any): p is TimeProp {
   return p?.type === "time";
@@ -327,6 +326,40 @@ export function isCustomJoinClause(p: any): p is { custom: string } {
 }
 
 /* 서브셋 */
+// type SubsetLoader = {
+//   as: string;
+//   table: string;
+//   manyJoin: {
+//     fromTable: string;
+//     fromCol: string;
+//     idField: string;
+//     toTable: string;
+//     toCol: string;
+//     through?: {
+//       table: string;
+//       fromCol: string;
+//       toCol: string;
+//     };
+//   };
+//   oneJoins: ({
+//     as: string;
+//     join: "inner" | "outer";
+//     table: string;
+//   } & JoinClause)[];
+//   select: (string | Knex.Raw)[];
+//   loaders?: SubsetLoader[];
+// };
+// export type SubsetQuery = {
+//   select: (string | Knex.Raw)[];
+//   virtual: string[];
+//   joins: ({
+//     as: string;
+//     join: "inner" | "outer";
+//     table: string;
+//   } & JoinClause)[];
+//   loaders: SubsetLoader[];
+// };
+
 type SubsetLoader = {
   as: string;
   table: string;
@@ -347,11 +380,12 @@ type SubsetLoader = {
     join: "inner" | "outer";
     table: string;
   } & JoinClause)[];
-  select: (string | Knex.Raw)[];
+  select: string[];
   loaders?: SubsetLoader[];
 };
+
 export type SubsetQuery = {
-  select: (string | Knex.Raw)[];
+  select: string[];
   virtual: string[];
   joins: ({
     as: string;
@@ -376,6 +410,9 @@ export type KnexError = {
 export function isKnexError(e: any): e is KnexError {
   return e.code && e.sqlMessage && e.sqlState;
 }
+export function isKyselyError(e: any): e is KnexError {
+  return e.code && e.sqlMessage && e.sqlState;
+}
 
 export type KnexColumnType =
   | "string"
@@ -394,7 +431,7 @@ export type KnexColumnType =
   | "float"
   | "date"
   | "time"
-  | "dateTime";
+  | "datetime";
 export type MigrationColumn = {
   name: string;
   type: KnexColumnType;
@@ -554,6 +591,11 @@ export namespace ApiParamType {
   export function isRefKnex(v: any): v is ApiParamType.Ref {
     return v?.t === "ref" && v.id === "Knex";
   }
+  export function isRefKysely(v: any): v is ApiParamType.Ref {
+    return (
+      v?.t === "ref" && (v.id === "Kysely" || v.id.startsWith("Transaction"))
+    );
+  }
   export function isTypeParam(v: any): v is ApiParamType.TypeParam {
     return v?.t === "type-param";
   }
@@ -684,6 +726,7 @@ export const TemplateOptions = z.object({
     entityId: z.string(),
     enumId: z.string(),
   }),
+  kysely_interface: z.object({}),
 });
 export type TemplateOptions = z.infer<typeof TemplateOptions>;
 
@@ -706,6 +749,7 @@ export const TemplateKey = z.enum([
   "view_enums_select",
   "view_enums_dropdown",
   "view_enums_buttonset",
+  "kysely_interface",
 ]);
 export type TemplateKey = z.infer<typeof TemplateKey>;
 
@@ -750,3 +794,9 @@ export type FixtureImportResult = {
     [key: string]: any;
   };
 };
+
+export type RelationNode = {
+  fixtureId: string;
+  entityId: string;
+  related: Set<string>;
+};

package/src/utils/utils.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import glob from "glob";
 import fs from "fs-extra";
+import _ from "lodash";
 
 export function globAsync(pathPattern: string): Promise<string[]> {
   return new Promise((resolve, reject) => {
@@ -20,10 +21,16 @@ export async function importMultiple(
   const results: { filePath: string; imported: any }[] = [];
 
   for (const filePath of filePaths) {
-    const importPath = "./" + path.relative(__dirname, filePath);
+    let importPath = "./" + path.relative(__dirname, filePath);
+
     if (doRefresh) {
-      delete require.cache[require.resolve(importPath)];
+      if (require.resolve) {
+        delete require.cache[require.resolve(importPath)];
+      } else {
+        importPath += `?t=${Date.now()}`;
+      }
     }
+
     const imported = await import(importPath);
     results.push({
       filePath,
@@ -34,11 +41,11 @@ export async function importMultiple(
   return results;
 }
 export async function findAppRootPath() {
-  const apiRootPath = await findApiRootPath();
+  const apiRootPath = findApiRootPath();
   return apiRootPath.split(path.sep).slice(0, -1).join(path.sep);
 }
 
-export async function findApiRootPath() {
+export function findApiRootPath() {
   const basePath = require.main?.path ?? __dirname;
   let dir = path.dirname(basePath);
   if (dir.includes("/.yarn/")) {
@@ -56,3 +63,48 @@ export async function findApiRootPath() {
 export function nonNullable<T>(value: T): value is NonNullable<T> {
   return value !== null && value !== undefined;
 }
+
+export function hydrate<T>(rows: T[]): T[] {
+  return rows.map((row: any) => {
+    // nullable relation인 경우 관련된 필드가 전부 null로 생성되는 것 방지하는 코드
+    const nestedKeys = Object.keys(row).filter((key) => key.includes("__"));
+    const groups = _.groupBy(nestedKeys, (key) => key.split("__")[0]);
+    const nullKeys = Object.keys(groups).filter(
+      (key) =>
+        groups[key].length > 1 &&
+        groups[key].every((field) => row[field] === null)
+    );
+
+    const hydrated = Object.keys(row).reduce((r, field) => {
+      if (!field.includes("__")) {
+        if (Array.isArray(row[field]) && _.isObject(row[field][0])) {
+          r[field] = hydrate(row[field]);
+          return r;
+        } else {
+          r[field] = row[field];
+          return r;
+        }
+      }
+
+      const parts = field.split("__");
+      const objPath =
+        parts[0] +
+        parts
+          .slice(1)
+          .map((part) => `[${part}]`)
+          .join("");
+      _.set(
+        r,
+        objPath,
+        row[field] && Array.isArray(row[field]) && _.isObject(row[field][0])
+          ? hydrate(row[field])
+          : row[field]
+      );
+
+      return r;
+    }, {} as any);
+    nullKeys.map((nullKey) => (hydrated[nullKey] = null));
+
+    return hydrated;
+  });
+}

package/src/utils/zod-error.ts

@@ -0,0 +1,189 @@
+import { z } from "zod";
+
+type ValidationError = {
+  path: string[];
+  message: string;
+};
+
+export function humanizeZodError(error: z.ZodError): ValidationError[] {
+  return error.issues.map((issue) => {
+    const pathAsStrings = issue.path.map(String);
+    const path = issue.path.reduce((acc, cur, i) => {
+      if (typeof cur === "number") {
+        return `${acc}[${cur}]`;
+      }
+      return i === 0 ? cur : `${acc}.${cur}`;
+    }, "");
+
+    switch (issue.code) {
+      case z.ZodIssueCode.invalid_type:
+        return {
+          path: pathAsStrings,
+          message: `${path} should be a ${issue.expected}, received ${issue.received}.`,
+        };
+
+      case z.ZodIssueCode.unrecognized_keys:
+        return {
+          path: pathAsStrings,
+          message: `Unrecognized keys in ${path}: ${issue.keys.join(", ")}.`,
+        };
+
+      case z.ZodIssueCode.invalid_union:
+        return {
+          path: pathAsStrings,
+          message: `${path} failed union validation. Inner errors: ${issue.unionErrors
+            .map((e) => e.issues.map((i) => i.message).join("; "))
+            .join(" OR ")}.`,
+        };
+
+      case z.ZodIssueCode.invalid_enum_value:
+        return {
+          path: pathAsStrings,
+          message: `${path} must be one of: ${issue.options.join(", ")}.`,
+        };
+
+      case z.ZodIssueCode.invalid_arguments:
+        return {
+          path: pathAsStrings,
+          message: `Invalid function arguments: ${issue.argumentsError.issues
+            .map((i) => i.message)
+            .join("; ")}.`,
+        };
+
+      case z.ZodIssueCode.invalid_return_type:
+        return {
+          path: pathAsStrings,
+          message: `Invalid function return type: ${issue.returnTypeError.issues
+            .map((i) => i.message)
+            .join("; ")}.`,
+        };
+
+      case z.ZodIssueCode.invalid_date:
+        return {
+          path: pathAsStrings,
+          message: `${path} must be a valid date.`,
+        };
+
+      case z.ZodIssueCode.invalid_string:
+        const validationType = issue.validation;
+        return {
+          path: pathAsStrings,
+          message: `${path} must be a valid ${validationType}.`,
+        };
+
+      case z.ZodIssueCode.too_small:
+        return {
+          path: pathAsStrings,
+          message: `${path} ${getMinimumMessage(issue)}.`,
+        };
+
+      case z.ZodIssueCode.too_big:
+        return {
+          path: pathAsStrings,
+          message: `${path} ${getMaximumMessage(issue)}`,
+        };
+
+      case z.ZodIssueCode.not_multiple_of:
+        return {
+          path: pathAsStrings,
+          message: `${path} must be a multiple of ${issue.multipleOf.toString()}.`,
+        };
+
+      case z.ZodIssueCode.custom:
+        return {
+          path: pathAsStrings,
+          message: issue.message || `${path} failed custom validation.`,
+        };
+
+      default:
+        return {
+          path: pathAsStrings,
+          message: issue.message,
+        };
+    }
+  });
+}
+
+function getMinimumMessage(
+  issue: z.ZodIssue & { code: typeof z.ZodIssueCode.too_small }
+) {
+  switch (issue.type) {
+    case "string":
+      return `must be ${
+        issue.exact ? "exactly" : issue.inclusive ? "at least" : "more than"
+      } ${issue.minimum} character${issue.minimum === 1 ? "" : "s"}`;
+
+    case "number":
+      return `must be ${
+        issue.exact
+          ? "exactly"
+          : issue.inclusive
+            ? "greater than or equal to"
+            : "greater than"
+      } ${issue.minimum.toString()}`;
+
+    case "array":
+    case "set":
+      return `must contain ${
+        issue.exact ? "exactly" : issue.inclusive ? "at least" : "more than"
+      } ${issue.minimum} item${issue.minimum === 1 ? "" : "s"}`;
+
+    case "date":
+      return `must be ${
+        issue.exact ? "exactly" : issue.inclusive ? "at or after" : "after"
+      } ${formatDateConstraint(issue.minimum)}`;
+
+    default:
+      return "is too small";
+  }
+}
+
+function getMaximumMessage(
+  issue: z.ZodIssue & { code: typeof z.ZodIssueCode.too_big }
+) {
+  switch (issue.type) {
+    case "string":
+      return `must be ${
+        issue.exact ? "exactly" : issue.inclusive ? "at most" : "less than"
+      } ${issue.maximum} character${issue.maximum === 1 ? "" : "s"}`;
+
+    case "number":
+      return `must be ${
+        issue.exact
+          ? "exactly"
+          : issue.inclusive
+            ? "less than or equal to"
+            : "less than"
+      } ${issue.maximum.toString()}`;
+
+    case "array":
+    case "set":
+      return `must contain ${
+        issue.exact ? "exactly" : issue.inclusive ? "at most" : "fewer than"
+      } ${issue.maximum} item${issue.maximum === 1 ? "" : "s"}`;
+
+    case "date":
+      return `must be ${
+        issue.exact ? "exactly" : issue.inclusive ? "at or before" : "before"
+      } ${formatDateConstraint(issue.maximum)}`;
+
+    default:
+      return "is too big";
+  }
+}
+
+function formatDateConstraint(value: number | bigint): string {
+  try {
+    if (typeof value === "bigint") {
+      if (
+        value > BigInt(Number.MAX_SAFE_INTEGER) ||
+        value < BigInt(Number.MIN_SAFE_INTEGER)
+      ) {
+        return value.toString();
+      }
+    }
+    return new Date(Number(value)).toISOString();
+  } catch {
+    return value.toString();
+  }
+}

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
     /* Basic Options */
-    "target": "es6",
-    "module": "commonjs",
+    "target": "ESNext",
+    "module": "ESNext",
     "outDir": "dist",
     "sourceMap": true,
     "lib": ["esnext", "dom"],

package/tsup.config.js

@@ -1,23 +1,24 @@
 // tsup.config.js
 import { defineConfig } from "tsup";
+import { ImportToRequirePlugin } from "./import-to-require";
 
 export default defineConfig({
-  entry: ["src/index.ts", "src/bin/cli.ts", "src/bin/cli-wrapper.ts"],
+  entry: [
+    "src/index.ts",
+    "src/bin/cli.ts",
+    "src/bin/cli-wrapper.ts",
+    "src/database/drivers/knex/base-model.ts",
+    "src/database/drivers/kysely/base-model.ts",
+  ],
   dts: true,
-  format: ["esm", "cjs"],
-  target: "es2020",
+  format: ["cjs", "esm"],
+  target: "esnext",
   clean: true,
   sourcemap: true,
   shims: true,
   platform: "node",
   splitting: true,
-  // banner(ctx) {
-  //   if (ctx.format === "esm") {
-  //     return {
-  //       js: `const require = (await import('module')).createRequire(import.meta.url);`,
-  //     };
-  //   }
-  // },
+  esbuildPlugins: [ImportToRequirePlugin],
   external: [
     "chalk",
     "dotenv",