sonamu 0.4.14 → 0.5.1

package/src/types/types.ts

@@ -1,6 +1,20 @@
+import type { GuardKey } from "./../api/decorators";
+import type { FastifyCorsOptions } from "@fastify/cors";
+import type { FastifyFormbodyOptions } from "@fastify/formbody";
+import type {
+  FastifyInstance,
+  FastifyReply,
+  FastifyRequest,
+  FastifyServerOptions,
+} from "fastify";
+import type { QsPluginOptions } from "fastify-qs";
 import { z } from "zod";
+import type { Context, ApiDecoratorOptions } from "../api";
+import type { FastifyMultipartOptions } from "@fastify/multipart";
+import type { Driver } from "../file-storage/driver";
+import type { SsePluginOptions } from "fastify-sse-v2/lib/types";
 
-/* 
+/*
   Enums
 */
 export type EnumsLabel<T extends string, L extends "ko" | "en"> = {
@@ -26,7 +40,7 @@ export type SQLDateTimeString = z.infer<typeof SQLDateTimeString>;
 */
 export function zArrayable<T extends z.ZodTypeAny>(
   shape: T
-): z.ZodUnion<[T, z.ZodArray<T, "many">]> {
+): z.ZodUnion<[T, z.ZodArray<T>]> {
   return z.union([shape, shape.array()]);
 }
 export type DistributiveOmit<T, K extends keyof any> = T extends any
@@ -186,9 +200,10 @@ export type EntityProp =
   | RelationProp;
 
 export type EntityIndex = {
-  type: "index" | "unique";
+  type: "index" | "unique" | "fulltext";
   columns: string[];
   name?: string;
+  parser?: "built-in" | "ngram";
 };
 export type EntityJson = {
   id: string;
@@ -412,9 +427,6 @@ 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"
@@ -446,7 +458,8 @@ export type MigrationColumn = {
 };
 export type MigrationIndex = {
   columns: string[];
-  type: "unique" | "index";
+  type: "unique" | "index" | "fulltext";
+  parser?: "built-in" | "ngram";
 };
 export type MigrationForeign = {
   columns: string[];
@@ -593,11 +606,6 @@ 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";
   }
@@ -635,6 +643,7 @@ export type RenderingNode = {
     | "string-image"
     | "string-datetime"
     | "string-date"
+    | "datetime"
     | "number-plain"
     | "number-id"
     | "number-fk_id"
@@ -738,7 +747,6 @@ export const TemplateOptions = z.object({
     entityId: z.string(),
     enumId: z.string(),
   }),
-  kysely_interface: z.object({}),
 });
 export type TemplateOptions = z.infer<typeof TemplateOptions>;
 
@@ -761,7 +769,6 @@ export const TemplateKey = z.enum([
   "view_enums_select",
   "view_enums_dropdown",
   "view_enums_buttonset",
-  "kysely_interface",
 ]);
 export type TemplateKey = z.infer<typeof TemplateKey>;
 
@@ -812,3 +819,90 @@ export type RelationNode = {
   entityId: string;
   related: Set<string>;
 };
+
+export interface DatabaseSchemaExtend {}
+export type ManyToManyBaseSchema<
+  FromIdKey extends string,
+  ToIdKey extends string,
+> = {
+  id: number;
+} & {
+  [K in `${FromIdKey}_id`]: number;
+} & {
+  [K in `${ToIdKey}_id`]: number;
+};
+
+export type SonamuFastifyConfig = {
+  contextProvider: (
+    defaultContext: Pick<
+      Context,
+      "request" | "reply" | "headers" | "createSSE"
+    >,
+    request: FastifyRequest,
+    reply: FastifyReply
+  ) => Context;
+  guardHandler: (
+    guard: GuardKey,
+    request: FastifyRequest,
+    api: {
+      typeParameters: ApiParamType.TypeParam[];
+      parameters: ApiParam[];
+      returnType: ApiParamType;
+      modelName: string;
+      methodName: string;
+      path: string;
+      options: ApiDecoratorOptions;
+    }
+  ) => void;
+  cache?: {
+    get: (key: string) => Promise<unknown | null>;
+    put: (key: string, value: unknown, ttl?: number) => Promise<void>;
+    resolveKey: (
+      path: string,
+      reqBody: {
+        [key: string]: unknown;
+      }
+    ) =>
+      | {
+          cache: false;
+        }
+      | {
+          cache: true;
+          key: string;
+          ttl?: number;
+        };
+  };
+};
+
+export type SonamuServerOptions = {
+  fastify?: FastifyServerOptions;
+
+  listen?: {
+    port: number;
+    host?: string;
+  };
+
+  plugins?: {
+    cors?: boolean | FastifyCorsOptions;
+    formbody?: boolean | FastifyFormbodyOptions;
+    multipart?: boolean | FastifyMultipartOptions;
+    qs?: boolean | QsPluginOptions;
+    sse?: boolean | SsePluginOptions;
+
+    custom?: (server: FastifyInstance) => void;
+  };
+
+  apiConfig: SonamuFastifyConfig;
+
+  storage?: Driver;
+
+  lifecycle?: {
+    onStart?: (server: FastifyInstance) => Promise<void> | void;
+    onShutdown?: (server: FastifyInstance) => Promise<void> | void;
+    onError?: (
+      error: Error,
+      request: FastifyRequest,
+      reply: FastifyReply
+    ) => Promise<void> | void;
+  };
+};

package/src/utils/async-utils.ts

@@ -0,0 +1,64 @@
+/**
+ * 비동기 조건으로 배열을 필터링합니다
+ * @example
+ * const filtered = await filterAsync([1, 2, 3], async (x) => x > 1);
+ */
+export async function filterAsync<T>(
+  arr: T[],
+  predicate: (item: T, index: number, array: T[]) => Promise<boolean>
+): Promise<T[]> {
+  const results = await Promise.all(
+    arr.map((item, index) =>
+      predicate(item, index, arr).then((keep) => ({ item, keep }))
+    )
+  );
+  return results.filter((r) => r.keep).map((r) => r.item);
+}
+
+/**
+ * 비동기 조건이 모든 요소에 대해 참인지 확인합니다
+ * @example
+ * const allValid = await everyAsync([1, 2, 3], async (x) => x > 0);
+ */
+export async function everyAsync<T>(
+  arr: T[],
+  predicate: (item: T, index: number, array: T[]) => Promise<boolean>
+): Promise<boolean> {
+  for (let i = 0; i < arr.length; i++) {
+    if (!(await predicate(arr[i], i, arr))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * 비동기 변환 함수를 배열의 각 요소에 적용합니다
+ * @example
+ * const doubled = await mapAsync([1, 2, 3], async (x) => x * 2);
+ */
+export async function mapAsync<T, U>(
+  arr: T[],
+  mapper: (item: T, index: number, array: T[]) => Promise<U>
+): Promise<U[]> {
+  return Promise.all(
+    arr.map((item, index) => mapper(item, index, arr))
+  );
+}
+
+/**
+ * 비동기 리듀서로 배열을 축약합니다
+ * @example
+ * const sum = await reduceAsync([1, 2, 3], async (acc, x) => acc + x, 0);
+ */
+export async function reduceAsync<T, U>(
+  arr: T[],
+  reducer: (accumulator: U, currentValue: T, index: number, array: T[]) => Promise<U>,
+  initialValue: U
+): Promise<U> {
+  let accumulator = initialValue;
+  for (let i = 0; i < arr.length; i++) {
+    accumulator = await reducer(accumulator, arr[i], i, arr);
+  }
+  return accumulator;
+}

package/src/utils/fs-utils.ts

@@ -0,0 +1,17 @@
+import { PathLike, constants } from "fs";
+import { access } from "fs/promises";
+
+/**
+ * fs/promises에는 exists가 없어요. 대신 access가 있습니다.
+ * 근데 얘는 인터페이스가 쓰기 불편해요. 그래서 감싸주었습니다.
+ * @param path
+ * @returns
+ */
+export async function exists(path: PathLike): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/model.ts

@@ -1,5 +1,3 @@
-import _ from "lodash";
-
 export type ListResult<T> = {
   rows: T[];
   total?: number;

package/src/utils/utils.ts

@@ -1,18 +1,13 @@
 import path from "path";
-import glob from "glob";
-import fs from "fs-extra";
-import _ from "lodash";
+import { glob } from "fs/promises";
+import fs from "fs";
 
-export function globAsync(pathPattern: string): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    glob(path.resolve(pathPattern), (err, files) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(files);
-      }
-    });
-  });
+export async function globAsync(pathPattern: string): Promise<string[]> {
+  const files: string[] = [];
+  for await (const file of glob(path.resolve(pathPattern))) {
+    files.push(file);
+  }
+  return files;
 }
 export async function importMultiple(
   filePaths: string[],
@@ -46,6 +41,12 @@ export async function findAppRootPath() {
 }
 
 export function findApiRootPath() {
+  // NOTE: for support npm / yarn workspaces
+  const workspacePath = process.env["INIT_CWD"];
+  if (workspacePath && workspacePath.length !== 0) {
+    return workspacePath;
+  }
+
   const basePath = require.main?.path ?? __dirname;
   let dir = path.dirname(basePath);
   if (dir.includes("/.yarn/")) {
@@ -63,48 +64,3 @@ export 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

@@ -1,4 +1,5 @@
-import { z } from "zod";
+
+import { z } from 'zod';
 
 type ValidationError = {
   path: string[];
@@ -6,184 +7,19 @@ type ValidationError = {
 };
 
 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 error.issues.map(({  path: originPath, message }) => {
+    const path = originPath.map(item => {
+      if (typeof item === "symbol") {
+        return item.description ?? item.toString();
       }
-      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()}.`,
-        };
+      if (typeof item === "number") {
+        return `[${item}]`;
+      }
 
-      case z.ZodIssueCode.custom:
-        return {
-          path: pathAsStrings,
-          message: issue.message || `${path} failed custom validation.`,
-        };
+      return item;
+    });
 
-      default:
-        return {
-          path: pathAsStrings,
-          message: issue.message,
-        };
-    }
+    return { path, message: 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

@@ -6,6 +6,10 @@
     "outDir": "dist",
     "sourceMap": true,
     "lib": ["esnext", "dom"],
+
+    // NOTE(Haze, 251106): SSE 관련 fastify 타입 이슈로 명시적으로 추가함.
+    "types": ["fastify-sse-v2"],
+
     "declaration": true,
     "declarationMap": true,
 
@@ -24,6 +28,8 @@
     "noUnusedParameters": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
+    "skipLibCheck": true,
+    // "noUncheckedIndexedAccess": true, // FIXME
 
     /* Module Resolution Options */
     "moduleResolution": "node",

package/tsup.config.js

@@ -11,7 +11,10 @@ export default defineConfig({
     "src/database/drivers/kysely/base-model.ts",
   ],
   dts: true,
-  format: ["cjs", "esm"],
+  format: [
+    "cjs",
+    // "esm"
+  ],
   target: "esnext",
   clean: true,
   sourcemap: true,
@@ -24,7 +27,6 @@ export default defineConfig({
     "dotenv",
     "fast-deep-equal",
     "fastify",
-    "fs-extra",
     "glob",
     "inflection",
     "knex",