sonamu 0.0.1

package/src/database/upsert-builder.ts

@@ -0,0 +1,231 @@
+import { v4 as uuidv4 } from "uuid";
+import _, { chunk, defaults, groupBy } from "lodash";
+import { Knex } from "knex";
+import { SMDManager } from "../smd/smd-manager";
+
+type TableData = {
+  references: Set<string>;
+  rows: any[];
+  uniqueColumns: string[];
+  uniquesMap: Map<string, string>;
+};
+export type UBRef = {
+  uuid: string;
+  of: string;
+  use?: string;
+};
+export function isRefField(field: any): field is UBRef {
+  return (
+    field !== undefined &&
+    field !== null &&
+    field.of !== undefined &&
+    field.uuid !== undefined
+  );
+}
+
+export class UpsertBuilder {
+  tables: Map<string, TableData>;
+  constructor() {
+    this.tables = new Map();
+  }
+
+  getTable(tableName: string): TableData {
+    const table = this.tables.get(tableName);
+    if (table === undefined) {
+      const tableSpec = (() => {
+        try {
+          return SMDManager.getTableSpec(tableName);
+        } catch {
+          return null;
+        }
+      })();
+
+      this.tables.set(tableName, {
+        references: new Set(),
+        rows: [],
+        uniqueColumns: tableSpec?.uniqueColumns ?? [],
+        uniquesMap: new Map<string, string>(),
+      });
+    }
+
+    return this.tables.get(tableName)!;
+  }
+
+  hasTable(tableName: string): boolean {
+    return this.tables.has(tableName);
+  }
+
+  register<T extends string>(
+    tableName: string,
+    row: {
+      [key in T]?: UBRef | string | number | boolean | bigint | null;
+    }
+  ): UBRef {
+    const table = this.getTable(tableName);
+
+    // uuid 생성 로직
+    let uuid: string | undefined;
+
+    // 해당 테이블의 unique 컬럼들의 값을 통해 키 생성
+    const uniqueKey = table.uniqueColumns
+      .map((unqCol) => row[unqCol as keyof typeof row])
+      .join("---delimiter--");
+    if (table.uniqueColumns.length > 0) {
+      // 기존 키가 있는 경우 uuid 그대로 사용
+      uuid = table.uniquesMap.get(uniqueKey);
+    }
+
+    // 없는 경우 uuid 생성하고, 생성한 uuid를 uniquesMap에 보관
+    if (!uuid) {
+      uuid = uuidv4();
+      table.uniquesMap.set(uniqueKey, uuid);
+    }
+
+    table.rows.push({
+      uuid,
+      ...row,
+    });
+
+    // 이 테이블에 사용된 RefField를 순회하여, 현재 테이블 정보에 어떤 필드를 참조하는지 추가
+    // 이 정보를 나중에 치환할 때 사용
+    row = Object.keys(row).reduce((r, rowKey) => {
+      const rowValue = row[rowKey as keyof typeof row];
+      if (isRefField(rowValue)) {
+        rowValue.use ??= "id";
+        table.references.add(rowValue.of + "." + rowValue.use);
+      }
+      r[rowKey] = rowValue;
+      return r;
+    }, {} as any);
+
+    return {
+      of: tableName,
+      uuid: (row as { uuid?: string }).uuid ?? uuid,
+    };
+  }
+
+  async upsert(wdb: Knex, tableName: string): Promise<number[]> {
+    if (this.hasTable(tableName) === false) {
+      return [];
+    }
+
+    const table = this.tables.get(tableName);
+    if (table === undefined) {
+      throw new Error(`존재하지 않는 테이블 ${tableName}에 upsert 요청`);
+    } else if (table.rows.length === 0) {
+      throw new Error(`${tableName}에 upsert 할 데이터가 없습니다.`);
+    }
+
+    if (
+      table.rows.some((row) =>
+        Object.entries(row).some(
+          ([, value]) => isRefField(value) && value.of !== tableName
+        )
+      )
+    ) {
+      throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
+    }
+
+    // 내부 참조 있는 경우 필터하여 분리
+    const groups = groupBy(table.rows, (row) =>
+      Object.entries(row).some(([, value]) => isRefField(value))
+        ? "selfRef"
+        : "normal"
+    );
+    const targetRows = groups.normal;
+
+    // Insert On Duplicate Update
+    const q = wdb.insert(targetRows).into(tableName);
+    await q.onDuplicateUpdate.apply(q, Object.keys(targetRows[0]));
+
+    // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출
+    const { references, refTables } = Array.from(this.tables).reduce(
+      (r, [, table]) => {
+        const reference = Array.from(table.references.values()).find((ref) =>
+          ref.includes(tableName + ".")
+        );
+        if (reference) {
+          r.references.push(reference);
+          r.refTables.push(table);
+        }
+
+        return r;
+      },
+      {
+        references: [] as string[],
+        refTables: [] as TableData[],
+      }
+    );
+
+    const extractFields = _.uniq(references).map(
+      (reference) => reference.split(".")[1]
+    );
+
+    // UUID 기준으로 id 추출
+    const uuids = table.rows.map((row) => row.uuid);
+    const upsertedRows = await wdb(tableName)
+      .select(_.uniq(["uuid", "id", ...extractFields]))
+      .whereIn("uuid", uuids);
+    const uuidMap = new Map<string, any>(
+      upsertedRows.map((row: any) => [row.uuid, row])
+    );
+
+    // 해당 테이블 참조를 실제 밸류로 변경
+    refTables.map((table) => {
+      table.rows = table.rows.map((row) => {
+        Object.keys(row).map((key) => {
+          const prop = row[key];
+          if (isRefField(prop) && prop.of === tableName) {
+            const parent = uuidMap.get(prop.uuid);
+            if (parent === undefined) {
+              console.error(prop);
+              throw new Error(
+                `존재하지 않는 uuid ${prop.uuid} -- in ${tableName}`
+              );
+            }
+            row[key] = parent[prop.use ?? "id"];
+          }
+        });
+        return row;
+      });
+    });
+
+    const ids = Array.from(uuidMap.values()).map((val) => val.id);
+
+    if (groups.selfRef) {
+      const selfRefIds = await this.upsert(wdb, tableName);
+      return [...ids, ...selfRefIds];
+    }
+
+    return ids;
+  }
+
+  async updateBatch(
+    wdb: Knex,
+    tableName: string,
+    options?: {
+      chunkSize?: number;
+      where?: string;
+    }
+  ): Promise<void> {
+    options = defaults(options, {
+      chunkSize: 500,
+    });
+
+    const table = this.tables.get(tableName);
+    if (table === undefined) {
+      throw new Error(`존재하지 않는 테이블 ${tableName}에 updateBatch 요청`);
+    } else if (table.rows.length === 0) {
+      throw new Error(`${tableName}에 updateBatch 할 데이터가 없습니다.`);
+    }
+
+    const chunks = chunk(table.rows, options.chunkSize);
+    for await (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async ({ id, ...row }) => {
+          return await wdb(tableName).where("id", id).update(row);
+        })
+      );
+    }
+  }
+}

package/src/exceptions/error-handler.ts

@@ -0,0 +1,29 @@
+import { FastifyInstance } from "fastify";
+import { ZodIssue } from "zod";
+import { isSoException } from "./so-exceptions";
+
+export function setupErrorHandler(server: FastifyInstance) {
+  server.setErrorHandler((error, _request, reply) => {
+    error.statusCode ??= 400;
+
+    if (isSoException(error) && error.payload && Array.isArray(error.payload)) {
+      const issues = error.payload as ZodIssue[];
+      const [issue] = issues;
+      const message = `${issue.message} (${issue.path.join("/")})`;
+      reply.status(error.statusCode <= 501 ? error.statusCode : 501).send({
+        name: error.name,
+        code: error.code,
+        message: message,
+        validationErrors: error.validation,
+        issues,
+      });
+    } else {
+      reply.status(error.statusCode <= 501 ? error.statusCode : 501).send({
+        name: error.name,
+        code: error.code,
+        message: error.message,
+        validationErrors: error.validation,
+      });
+    }
+  });
+}

package/src/exceptions/so-exceptions.ts

@@ -0,0 +1,91 @@
+export abstract class SoException extends Error {
+  constructor(
+    public readonly statusCode: number,
+    public message: string,
+    public payload?: unknown
+  ) {
+    super(message);
+  }
+}
+
+export function isSoException(err: any): err is SoException {
+  return err.statusCode !== undefined;
+}
+
+/*
+	잘못된 매개변수 등 요청사항에 문제가 있는 경우
+*/
+export class BadRequestException extends SoException {
+  constructor(public message = "Bad Request", public payload?: unknown) {
+    super(400, message, payload);
+  }
+}
+
+/*
+	로그인이 반드시 필요한 케이스에 로그아웃 상태인 경우 / 접근 권한이 없는 요청시
+*/
+export class UnauthorizedException extends SoException {
+  constructor(public message = "Unauthorized", public payload?: unknown) {
+    super(401, message, payload);
+  }
+}
+
+/*
+	존재하지 않는 레코드에 접근시
+*/
+export class NotFoundException extends SoException {
+  constructor(public message = "Not Found", public payload?: unknown) {
+    super(404, message, payload);
+  }
+}
+
+/*
+	현재 상태에서 처리가 불가능한 케이스
+*/
+export class ServiceUnavailableException extends SoException {
+  constructor(
+    public message = "Service Unavailable",
+    public payload?: unknown
+  ) {
+    super(503, message, payload);
+  }
+}
+
+/*
+	내부 처리 로직 (외부 API 콜 포함) 오류 발생시
+*/
+export class InternalServerErrorException extends SoException {
+  constructor(
+    public message = "Internal Server Error",
+    public payload?: unknown
+  ) {
+    super(500, message, payload);
+  }
+}
+
+/*
+	이미 처리함
+*/
+export class AlreadyProcessedException extends SoException {
+  constructor(public message = "Already Processed", public payload?: unknown) {
+    super(641, message, payload);
+  }
+}
+
+/*
+	중복 허용하지 않는 케이스에 중복 요청
+*/
+export class DuplicateRowException extends SoException {
+  constructor(public message = "Duplicate Row", public payload?: unknown) {
+    super(642, message, payload);
+  }
+}
+
+/*
+	뭔가를 하려고 했으나 대상이 없음
+*/
+export class TargetNotFoundException extends SoException {
+  constructor(public message = "Target Not Found", public payload?: unknown) {
+    super(620, message, payload);
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from "./api/code-converters";
+export * from "./api/context";
+export * from "./api/decorators";
+export * from "./api/init";
+export * from "./database/base-model";
+export * from "./database/db";
+export * from "./database/upsert-builder";
+export * from "./exceptions/error-handler";
+export * from "./exceptions/so-exceptions";
+export * from "./smd/smd-manager";
+export * from "./smd/smd-utils";
+export * from "./syncer/syncer";
+export * from "./testing/fixture-manager";
+export * from "./types/types";
+export * from "./utils/controller";
+export * from "./utils/model";
+export * from "./utils/utils";

package/src/shared/web.shared.ts.txt

@@ -0,0 +1,119 @@
+/*
+  fetch
+*/
+import type { AxiosRequestConfig } from "axios";
+import axios from "axios";
+import { z, ZodIssue } from "zod";
+
+export async function fetch(options: AxiosRequestConfig) {
+  try {
+    const res = await axios({
+      ...options,
+    });
+    return res.data;
+  } catch (e: unknown) {
+    if (axios.isAxiosError(e) && e.response && e.response.data) {
+      const d = e.response.data as {
+        message: string;
+        issues: ZodIssue[];
+      };
+      throw new SonamuError(e.response.status, d.message, d.issues);
+    }
+    throw e;
+  }
+}
+
+export class SonamuError extends Error {
+  isSonamuError: boolean;
+
+  constructor(
+    public code: number,
+    public message: string,
+    public issues: z.ZodIssue[]
+  ) {
+    super(message);
+    this.isSonamuError = true;
+  }
+}
+export function isSonamuError(e: any): e is SonamuError {
+  return e && e.isSonamuError === true;
+}
+
+export function defaultCatch(e: any) {
+  if (isSonamuError(e)) {
+    alert(e.message);
+  } else {
+    alert("에러 발생");
+  }
+}
+
+/*
+  Isomorphic Types
+*/
+export type ListResult<T> = {
+  rows: T[];
+  total?: number;
+};
+
+export type EnumsLabel<T extends string, L extends "ko" | "en"> = {
+  [key in T]: { [lang in L]: string };
+};
+export type EnumsLabelKo<T extends string> = EnumsLabel<T, "ko">;
+
+/*
+  SWR
+*/
+export type SwrOptions = {
+  conditional?: () => boolean;
+};
+export type SWRError = {
+  name: string;
+  message: string;
+  statusCode: number;
+};
+export async function swrFetcher(
+  url: string,
+  params: string = ""
+): Promise<any> {
+  try {
+    const res = await axios.get(url + "?" + params);
+    return res.data;
+  } catch (e: any) {
+    const error: any = new Error(
+      e.response.data.message ?? e.response.message ?? "Unknown"
+    );
+    error.statusCode = e.response?.data.statusCode ?? e.response.status;
+    throw error;
+  }
+}
+export function handleConditional(
+  route: string | string[],
+  conditional?: () => boolean
+): string | string[] | null {
+  if (conditional) {
+    return conditional() ? route : null;
+  }
+  return route;
+}
+
+/*
+  Utils
+*/
+export function zArrayable<T extends z.ZodTypeAny>(
+  shape: T
+): z.ZodUnion<[T, z.ZodArray<T, "many">]> {
+  return z.union([shape, shape.array()]);
+}
+
+/*
+  Custom Scalars
+*/
+export const SQLDateTimeString = z
+  .string()
+  .regex(/([0-9]{4}-[0-9]{2}-[0-9]{2}( [0-9]{2}:[0-9]{2}:[0-9]{2})*)$/, {
+    message: "잘못된 SQLDate 타입",
+  })
+  .min(10)
+  .max(19)
+  .describe("SQLDateTimeString");
+export type SQLDateTimeString = z.infer<typeof SQLDateTimeString>;