@cartanova/qgrid-cli 1.0.1 → 1.0.3

package/bundle/src/application/sonamu.generated.ts

@@ -0,0 +1,135 @@
+/**
+ * @generated
+ * 직접 수정하지 마세요.
+ */
+/* oxlint-disable */
+
+import { zArrayable, SonamuQueryMode, ApplySonamuFilter } from "sonamu";
+import { z } from "zod";
+
+// Enums: RequestLog
+export const RequestLogOrderBy = z.enum(["id-desc"]).describe("RequestLogOrderBy");
+export type RequestLogOrderBy = z.infer<typeof RequestLogOrderBy>;
+export const RequestLogOrderByLabel = { "id-desc": "ID최신순" };
+export const RequestLogSearchField = z
+  .enum(["id", "token_name", "query"])
+  .describe("RequestLogSearchField");
+export type RequestLogSearchField = z.infer<typeof RequestLogSearchField>;
+export const RequestLogSearchFieldLabel = { id: "ID", token_name: "토큰이름", query: "쿼리" };
+
+// Enums: Token
+export const TokenOrderBy = z.enum(["id-desc"]).describe("TokenOrderBy");
+export type TokenOrderBy = z.infer<typeof TokenOrderBy>;
+export const TokenOrderByLabel = { "id-desc": "ID최신순" };
+export const TokenSearchField = z.enum(["id", "name"]).describe("TokenSearchField");
+export type TokenSearchField = z.infer<typeof TokenSearchField>;
+export const TokenSearchFieldLabel = { id: "ID", name: "이름" };
+
+// BaseSchema: RequestLog
+export const RequestLogBaseSchema = z.object({
+  id: z.int(),
+  created_at: z.date(),
+  token_name: z.string().max(100),
+  query: z.string(),
+  response: z.string(),
+  input_tokens: z.int(),
+  output_tokens: z.int(),
+  cache_read_tokens: z.int(),
+  cache_creation_tokens: z.int(),
+  duration_ms: z.int(),
+});
+export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
+  readonly __hasDefault__: readonly ["created_at", "id"];
+};
+
+// BaseSchema: Token
+export const TokenBaseSchema = z.object({
+  id: z.int(),
+  created_at: z.date(),
+  token: z.string(),
+  name: z.string(),
+  refresh_token: z.string().nullable(),
+  expires_at: z.bigint().nullable(),
+  account_uuid: z.string().nullable(),
+  active: z.boolean(),
+});
+export type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {
+  readonly __hasDefault__: readonly [
+    "created_at",
+    "refresh_token",
+    "expires_at",
+    "account_uuid",
+    "active",
+    "id",
+  ];
+};
+
+// BaseListParams: RequestLog
+export const RequestLogBaseListParams = z
+  .object({
+    num: z.number().int().nonnegative(),
+    page: z.number().int().min(1),
+    search: RequestLogSearchField,
+    keyword: z.string(),
+    orderBy: RequestLogOrderBy,
+    queryMode: SonamuQueryMode,
+    id: zArrayable(z.number().int().positive()),
+    sonamuFilter: z.custom<ApplySonamuFilter<RequestLogBaseSchema, never, never>>(),
+    token_name: z.string().max(100),
+  })
+  .partial();
+export type RequestLogBaseListParams = z.infer<typeof RequestLogBaseListParams>;
+
+// BaseListParams: Token
+export const TokenBaseListParams = z
+  .object({
+    num: z.number().int().nonnegative(),
+    page: z.number().int().min(1),
+    search: TokenSearchField,
+    keyword: z.string(),
+    orderBy: TokenOrderBy,
+    queryMode: SonamuQueryMode,
+    id: zArrayable(z.number().int().positive()),
+    sonamuFilter: z.custom<ApplySonamuFilter<TokenBaseSchema, never, never>>(),
+    token: z.string(),
+  })
+  .partial();
+export type TokenBaseListParams = z.infer<typeof TokenBaseListParams>;
+
+// Subsets: RequestLog
+export const RequestLogSubsetA = z.object({
+  id: z.int(),
+  created_at: z.date(),
+  token_name: z.string().max(100),
+  query: z.string(),
+  response: z.string(),
+  input_tokens: z.int(),
+  output_tokens: z.int(),
+  cache_read_tokens: z.int(),
+  cache_creation_tokens: z.int(),
+  duration_ms: z.int(),
+});
+export type RequestLogSubsetA = z.infer<typeof RequestLogSubsetA>;
+export type RequestLogSubsetMapping = {
+  A: RequestLogSubsetA;
+};
+export const RequestLogSubsetKey = z.enum(["A"]);
+export type RequestLogSubsetKey = z.infer<typeof RequestLogSubsetKey>;
+
+// Subsets: Token
+export const TokenSubsetA = z.object({
+  id: z.int(),
+  created_at: z.date(),
+  token: z.string(),
+  name: z.string(),
+  refresh_token: z.string().nullable(),
+  expires_at: z.bigint().nullable(),
+  account_uuid: z.string().nullable(),
+  active: z.boolean(),
+});
+export type TokenSubsetA = z.infer<typeof TokenSubsetA>;
+export type TokenSubsetMapping = {
+  A: TokenSubsetA;
+};
+export const TokenSubsetKey = z.enum(["A"]);
+export type TokenSubsetKey = z.infer<typeof TokenSubsetKey>;

package/bundle/src/application/token/token.model.ts

@@ -0,0 +1,160 @@
+import {
+  api,
+  asArray,
+  BadRequestException,
+  BaseModelClass,
+  exhaustive,
+  type ListResult,
+  NotFoundException,
+} from "sonamu";
+
+import { SD } from "../../i18n/sd.generated";
+import type { TokenSubsetKey, TokenSubsetMapping } from "../sonamu.generated";
+import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso";
+import type { TokenListParams, TokenSaveParams } from "./token.types";
+
+class TokenModelClass extends BaseModelClass<
+  TokenSubsetKey,
+  TokenSubsetMapping,
+  typeof tokenSubsetQueries,
+  typeof tokenLoaderQueries
+> {
+  constructor() {
+    super("Token", tokenSubsetQueries, tokenLoaderQueries);
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "Token" })
+  async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {
+    const { rows } = await this.findMany(subset, { id, num: 1, page: 1 });
+    if (!rows[0]) {
+      throw new NotFoundException(SD("error.entityNotFound")("Token", id));
+    }
+    return rows[0];
+  }
+
+  async findOne<T extends TokenSubsetKey>(
+    subset: T,
+    listParams: TokenListParams,
+  ): Promise<TokenSubsetMapping[T] | null> {
+    const { rows } = await this.findMany(subset, { ...listParams, num: 1, page: 1 });
+    return rows[0] ?? null;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "Tokens" })
+  async findMany<T extends TokenSubsetKey, LP extends TokenListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): Promise<ListResult<LP, TokenSubsetMapping[T]>> {
+    const params = {
+      num: 24,
+      page: 1,
+      search: "id" as const,
+      orderBy: "id-desc" as const,
+      ...rawParams,
+    } satisfies TokenListParams;
+
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+
+    if (params.id) {
+      qb.whereIn("tokens.id", asArray(params.id));
+    }
+
+    if (params.token) {
+      qb.where("tokens.token", params.token);
+    }
+
+    if (params.search && params.keyword && params.keyword.length > 0) {
+      if (params.search === "id") {
+        qb.where("tokens.id", Number(params.keyword));
+      } else if (params.search === "name") {
+        qb.where("tokens.name", "like", `%${params.keyword}%`);
+      } else {
+        throw new BadRequestException(SD("error.unknownSearchField")(params.search));
+      }
+    }
+
+    if (params.orderBy) {
+      if (params.orderBy === "id-desc") {
+        qb.orderBy("tokens.id", "desc");
+      } else {
+        exhaustive(params.orderBy);
+      }
+    }
+
+    const enhancers = this.createEnhancers({
+      A: (row) => ({ ...row }),
+    });
+
+    return this.executeSubsetQuery({ subset, qb, params, enhancers, debug: false });
+  }
+
+  async findByToken<T extends TokenSubsetKey>(
+    subset: T,
+    token: string,
+  ): Promise<TokenSubsetMapping[T] | null> {
+    const { qb } = this.getSubsetQueries(subset);
+    qb.where("tokens.token", token);
+    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+    const result = await this.executeSubsetQuery({
+      subset,
+      qb,
+      params: { num: 1, page: 1 },
+      enhancers,
+      debug: false,
+    });
+    return result.rows[0] ?? null;
+  }
+
+  async findByAccountUuid<T extends TokenSubsetKey>(
+    subset: T,
+    accountUuid: string,
+  ): Promise<TokenSubsetMapping[T][]> {
+    const { qb } = this.getSubsetQueries(subset);
+    qb.where("tokens.account_uuid", accountUuid);
+    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+    const result = await this.executeSubsetQuery({
+      subset,
+      qb,
+      params: { num: 100, page: 1 },
+      enhancers,
+      debug: false,
+    });
+    return result.rows;
+  }
+
+  async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {
+    const { qb } = this.getSubsetQueries(subset);
+    qb.where("tokens.active", true);
+    const enhancers = this.createEnhancers({ A: (row) => ({ ...row }) });
+    const result = await this.executeSubsetQuery({
+      subset,
+      qb,
+      params: { num: 100, page: 1 },
+      enhancers,
+      debug: false,
+    });
+    return result.rows;
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async save(spa: TokenSaveParams[]): Promise<number[]> {
+    const wdb = this.getPuri("w");
+    spa.forEach((sp) => {
+      wdb.ubRegister("tokens", sp);
+    });
+    return wdb.transaction(async (trx) => {
+      return trx.ubUpsert("tokens");
+    });
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async del(ids: number[]): Promise<number> {
+    const wdb = this.getPuri("w");
+    await wdb.transaction(async (trx) => {
+      return trx.table("tokens").whereIn("tokens.id", ids).delete();
+    });
+    return ids.length;
+  }
+}
+
+export const TokenModel = new TokenModelClass();

package/bundle/src/application/token/token.types.ts

@@ -0,0 +1,26 @@
+import type { z } from "zod";
+
+import { TokenBaseListParams, TokenBaseSchema } from "../sonamu.generated";
+
+// Token - ListParams
+export const TokenListParams = TokenBaseListParams;
+export type TokenListParams = z.infer<typeof TokenListParams>;
+
+// Token - SaveParams
+export const TokenSaveParams = TokenBaseSchema.partial({
+  id: true,
+  created_at: true,
+  refresh_token: true,
+  expires_at: true,
+  account_uuid: true,
+  active: true,
+});
+export type TokenSaveParams = z.infer<typeof TokenSaveParams>;
+
+export const refreshTokenParams = TokenSaveParams.pick({
+  id: true,
+  token: true,
+  refresh_token: true,
+  name: true,
+});
+export type RefreshTokenParams = z.infer<typeof refreshTokenParams>;

package/bundle/src/i18n/en.ts

@@ -0,0 +1,59 @@
+import { plural } from "sonamu/dict";
+
+/**
+ * Project EN Dictionary
+ */
+export default {
+  "common.all": "All",
+  "common.backToList": "Back to List",
+  "common.cancel": "Cancel",
+  "common.close": "Close",
+  "common.confirm": "Confirm",
+  "common.create": "Create",
+  "common.createdAt": "Created At",
+  "common.delete": "Delete",
+  "common.edit": "Edit",
+  "common.login": "Login",
+  "common.logout": "Logout",
+  "common.manage": "Manage",
+  "common.results": (count: number) =>
+    plural(count, { one: `${count} result`, other: `${count} results` }),
+  "common.save": "Save",
+  "common.search": "Search",
+  "common.searchPlaceholder": "Search...",
+  "common.searchType": "Search Type",
+  "common.sort": "Sort",
+  "confirm.delete": "Are you sure you want to delete?",
+  "confirm.save": "Do you want to save?",
+  "dashboard.adminMenu": "Admin Menu",
+  "dashboard.createdAt": "Joined",
+  "dashboard.email": "Email",
+  "dashboard.loginRequired": "Please login to continue.",
+  "dashboard.name": "Name",
+  "dashboard.role": "Role",
+  "dashboard.title": "Admin Dashboard",
+  "dashboard.welcome": "Welcome!",
+  "delete.confirm.description":
+    "This action cannot be undone. This will permanently delete this item.",
+  "delete.confirm.title": "Are you sure?",
+  "entity.create": (name: string) => `Create ${name}`,
+  "entity.edit": (name: string, id: number) => `Edit ${name} (#${id})`,
+  "entity.list": (name: string) => `${name} List`,
+  "entity.listManage": (name: string) => `Manage ${name} List`,
+  "error.alreadyProcessed": "Already processed",
+  "error.badRequest": "Bad request",
+  "error.duplicateRow": "Duplicate data",
+  "error.forbidden": "Forbidden",
+  "error.internalServerError": "Internal server error",
+  "error.notFound": "Not found",
+  "error.serviceUnavailable": "Service unavailable",
+  "error.unauthorized": "Unauthorized",
+  notFound: (name: string, id: number) => `${name} ID ${id} not found`,
+  "validation.email": "Invalid email format",
+  "validation.maxLength": (field: string, max: number) =>
+    `${field} must be at most ${max} characters`,
+  "validation.minLength": (field: string, min: number) =>
+    `${field} must be at least ${min} characters`,
+  "validation.required": (field: string) => `${field} is required`,
+  "validation.url": "Invalid URL format",
+};

package/bundle/src/i18n/ko.ts

@@ -0,0 +1,59 @@
+import { josa } from "sonamu/dict";
+
+/**
+ * Project KO Dictionary
+ */
+export default {
+  "common.all": "전체",
+  "common.backToList": "목록으로",
+  "common.cancel": "취소",
+  "common.close": "닫기",
+  "common.confirm": "확인",
+  "common.create": "생성",
+  "common.createdAt": "등록",
+  "common.delete": "삭제",
+  "common.edit": "수정",
+  "common.login": "로그인",
+  "common.logout": "로그아웃",
+  "common.manage": "관리",
+  "common.results": (count: number) => `${count}개 결과`,
+  "common.save": "저장",
+  "common.search": "검색",
+  "common.searchPlaceholder": "검색...",
+  "common.searchType": "검색 유형",
+  "common.sort": "정렬",
+  "confirm.delete": "정말 삭제하시겠습니까?",
+  "confirm.save": "저장하시겠습니까?",
+  "dashboard.adminMenu": "관리 메뉴",
+  "dashboard.createdAt": "가입일",
+  "dashboard.email": "이메일",
+  "dashboard.loginRequired": "로그인이 필요합니다.",
+  "dashboard.name": "이름",
+  "dashboard.role": "역할",
+  "dashboard.title": "관리자 대시보드",
+  "dashboard.welcome": "환영합니다!",
+  "delete.confirm.description": "이 작업은 취소할 수 없습니다. 항목이 영구적으로 삭제됩니다.",
+  "delete.confirm.title": "정말 삭제하시겠습니까?",
+  "entity.create": (name: string) => `${name} 생성`,
+  "entity.edit": (name: string, id: number) => `${name} 수정 (#${id})`,
+  "entity.list": (name: string) => `${name} 목록`,
+  "entity.listManage": (name: string) => `${name} 목록 관리`,
+  "error.alreadyProcessed": "이미 처리되었습니다",
+  "error.badRequest": "잘못된 요청입니다",
+  "error.duplicateRow": "중복된 데이터입니다",
+  "error.entityNotFound": (name: string, id: number | string) => `존재하지 않는 ${name} ID ${id}`,
+  "error.forbidden": "권한이 없습니다",
+  "error.internalServerError": "서버 오류가 발생했습니다",
+  "error.notFound": "찾을 수 없습니다",
+  "error.serviceUnavailable": "서비스를 사용할 수 없습니다",
+  "error.unauthorized": "인증이 필요합니다",
+  "error.unknownSearchField": (field: string) => `구현되지 않은 검색 필드 ${field}`,
+  notFound: (name: string, id: number) => `존재하지 않는 ${name} ID ${id}`,
+  "validation.email": "올바른 이메일 형식이 아닙니다",
+  "validation.maxLength": (field: string, max: number) =>
+    `${field}${josa(field, "은는")} 최대 ${max}자까지 입력할 수 있습니다`,
+  "validation.minLength": (field: string, min: number) =>
+    `${field}${josa(field, "은는")} 최소 ${min}자 이상이어야 합니다`,
+  "validation.required": (field: string) => `${josa(field, "은는")} 필수입니다`,
+  "validation.url": "올바른 URL 형식이 아닙니다",
+} as const;