@cartanova/qgrid-cli 1.0.1 → 1.0.3

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

@@ -0,0 +1,187 @@
+# @generated
+# 직접 수정하지 마세요.
+
+GET {{baseUrl}}/api/token/findById
+	?subset=A
+	&id=0
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/token/findMany
+	?subset=A
+	&rawParams[num]=24
+	&rawParams[page]=1
+	&rawParams[search]=id
+	&rawParams[keyword]=KEYWORD
+	&rawParams[orderBy]=id-desc
+	&rawParams[queryMode]=both
+	&rawParams[id]=0
+	&rawParams[sonamuFilter]=unknown-custom
+	&rawParams[token]=TOKEN
+Content-Type: application/json
+
+###
+
+POST {{baseUrl}}/api/token/save
+Content-Type: application/json
+
+{
+  "spa": [
+    {
+      "id": 0,
+      "created_at": "2000-01-01",
+      "token": "TOKEN",
+      "name": "NAME",
+      "refresh_token": null,
+      "expires_at": null,
+      "account_uuid": null,
+      "active": false
+    }
+  ]
+}
+
+###
+
+POST {{baseUrl}}/api/token/del
+Content-Type: application/json
+
+{
+  "ids": [
+    0
+  ]
+}
+
+###
+
+GET {{baseUrl}}/api/requestLog/findById
+	?subset=A
+	&id=0
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/requestLog/findMany
+	?subset=A
+	&rawParams[num]=24
+	&rawParams[page]=1
+	&rawParams[search]=id
+	&rawParams[keyword]=KEYWORD
+	&rawParams[orderBy]=id-desc
+	&rawParams[queryMode]=both
+	&rawParams[id]=0
+	&rawParams[sonamuFilter]=unknown-custom
+	&rawParams[token_name]=TOKEN_NAME
+Content-Type: application/json
+
+###
+
+POST {{baseUrl}}/api/requestLog/save
+Content-Type: application/json
+
+{
+  "spa": [
+    {
+      "id": 0,
+      "created_at": "2000-01-01",
+      "token_name": "TOKEN_NAME",
+      "query": "QUERY",
+      "response": "RESPONSE",
+      "input_tokens": 0,
+      "output_tokens": 0,
+      "cache_read_tokens": 0,
+      "cache_creation_tokens": 0,
+      "duration_ms": 0
+    }
+  ]
+}
+
+###
+
+POST {{baseUrl}}/api/requestLog/del
+Content-Type: application/json
+
+{
+  "ids": [
+    0
+  ]
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/query
+Content-Type: application/json
+
+{
+  "prompt": "PROMPT",
+  "system": "SYSTEM",
+  "timeout": 0
+}
+
+###
+
+GET {{baseUrl}}/api/qgrid/stats
+	?
+Content-Type: application/json
+
+###
+
+POST {{baseUrl}}/api/qgrid/addToken
+Content-Type: application/json
+
+{
+  "token": "TOKEN",
+  "name": "NAME",
+  "refreshToken": "REFRESHTOKEN"
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/updateToken
+Content-Type: application/json
+
+{
+  "token": "TOKEN",
+  "name": "NAME",
+  "newToken": "NEWTOKEN",
+  "refreshToken": "REFRESHTOKEN"
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/removeToken
+Content-Type: application/json
+
+{
+  "token": "TOKEN"
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/toggleToken
+Content-Type: application/json
+
+{
+  "id": 0
+}
+
+###
+
+POST {{baseUrl}}/api/qgrid/oauthStart
+Content-Type: application/json
+
+{
+  "name": "NAME"
+}
+
+###
+
+GET {{baseUrl}}/api/qgrid/usage
+	?tokenName=TOKENNAME
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/qgrid/health
+	?
+Content-Type: application/json

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

@@ -0,0 +1,66 @@
+/**
+ * @generated
+ * 직접 수정하지 마세요.
+ */
+import { PuriWrapper, DatabaseSchemaExtend, PuriLoaderQueries } from "sonamu";
+
+import {
+  RequestLogSubsetKey,
+  TokenSubsetKey,
+  RequestLogBaseSchema,
+  TokenBaseSchema,
+} from "./sonamu.generated";
+
+// SubsetQuery: RequestLog
+export const requestLogSubsetQueries = {
+  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
+    return qbWrapper.from("request_logs").select({
+      id: "request_logs.id",
+      created_at: "request_logs.created_at",
+      token_name: "request_logs.token_name",
+      query: "request_logs.query",
+      response: "request_logs.response",
+      input_tokens: "request_logs.input_tokens",
+      output_tokens: "request_logs.output_tokens",
+      cache_read_tokens: "request_logs.cache_read_tokens",
+      cache_creation_tokens: "request_logs.cache_creation_tokens",
+      duration_ms: "request_logs.duration_ms",
+    });
+  },
+};
+
+// LoaderQuery: RequestLog
+export const requestLogLoaderQueries = {
+  A: [],
+} as const satisfies PuriLoaderQueries<RequestLogSubsetKey>;
+
+// SubsetQuery: Token
+export const tokenSubsetQueries = {
+  A: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
+    return qbWrapper.from("tokens").select({
+      id: "tokens.id",
+      created_at: "tokens.created_at",
+      token: "tokens.token",
+      name: "tokens.name",
+      refresh_token: "tokens.refresh_token",
+      expires_at: "tokens.expires_at",
+      account_uuid: "tokens.account_uuid",
+      active: "tokens.active",
+    });
+  },
+};
+
+// LoaderQuery: Token
+export const tokenLoaderQueries = {
+  A: [],
+} as const satisfies PuriLoaderQueries<TokenSubsetKey>;
+
+// DatabaseSchema
+declare module "sonamu" {
+  export interface DatabaseSchemaExtend {
+    request_logs: RequestLogBaseSchema;
+    tokens: TokenBaseSchema;
+  }
+
+  export interface DatabaseForeignKeys {}
+}

package/bundle/src/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/src/application/token/token.entity.json

@@ -0,0 +1,37 @@
+{
+  "id": "Token",
+  "table": "tokens",
+  "title": "Token",
+  "props": [
+    { "name": "id", "type": "integer", "desc": "ID" },
+    { "name": "created_at", "type": "date", "desc": "등록일시", "dbDefault": "CURRENT_TIMESTAMP" },
+    { "name": "token", "toFilter": true, "desc": "access_token", "type": "string" },
+    { "name": "name", "desc": "토큰 이름", "type": "string" },
+    { "name": "refresh_token", "type": "string", "nullable": true, "desc": "refresh_token" },
+    {
+      "name": "expires_at",
+      "type": "bigInteger",
+      "nullable": true,
+      "desc": "만료 시각 (epoch ms)"
+    },
+    { "name": "account_uuid", "type": "string", "nullable": true, "desc": "Anthropic 계정 UUID" },
+    { "name": "active", "type": "boolean", "desc": "활성 여부", "dbDefault": "true" }
+  ],
+  "indexes": [],
+  "subsets": {
+    "A": [
+      "id",
+      "created_at",
+      "token",
+      "name",
+      "refresh_token",
+      "expires_at",
+      "account_uuid",
+      "active"
+    ]
+  },
+  "enums": {
+    "TokenOrderBy": { "id-desc": "ID최신순" },
+    "TokenSearchField": { "id": "ID", "name": "이름" }
+  }
+}

package/bundle/src/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/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/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",
+};