sonamu 0.8.24 → 0.8.26

package/dist/auth/knex-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { BetterAuthOptions } from "better-auth";
+import type { Knex } from "knex";
+interface CleanedWhere {
+    field: string;
+    value: string | number | boolean | string[] | number[] | Date | null;
+    operator: string;
+    connector: string;
+}
+/**
+ * better-auth용 Sonamu knex 어댑터
+ *
+ * better-auth의 모든 쿼리를 DB.getDB()를 통해 실행하여
+ * Sonamu 테스트 트랜잭션과 동일한 커넥션을 공유합니다.
+ */
+export declare const sonamuKnexAdapter: () => (options: BetterAuthOptions) => import("better-auth").DBAdapter<BetterAuthOptions>;
+/**
+ * Better Auth의 공식 어댑터(Kysely, Drizzle, Prisma, MongoDB) 패턴에 맞춰
+ * AND 그룹과 OR 그룹을 분리한 뒤 top-level AND로 결합합니다.
+ * 결과: (A AND B AND ...) AND (C OR D OR ...)
+ */
+export declare function applyWhere(query: Knex.QueryBuilder, conditions: CleanedWhere[]): Knex.QueryBuilder;
+export {};
+//# sourceMappingURL=knex-adapter.d.ts.map

package/dist/auth/knex-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knex-adapter.d.ts","sourceRoot":"","sources":["../../src/auth/knex-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAMrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,SAyGpB,SAAS,iBAAiB,uDAInC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,IAAI,CAAC,YAAY,EACxB,UAAU,EAAE,YAAY,EAAE,GACzB,IAAI,CAAC,YAAY,CAmBnB"}

package/dist/auth/knex-adapter.js

@@ -0,0 +1,163 @@
+import { createAdapterFactory } from "better-auth/adapters";
+import { DB } from "../database/db.js";
+/**
+ * better-auth용 Sonamu knex 어댑터
+ *
+ * better-auth의 모든 쿼리를 DB.getDB()를 통해 실행하여
+ * Sonamu 테스트 트랜잭션과 동일한 커넥션을 공유합니다.
+ */ export const sonamuKnexAdapter = ()=>{
+    let lazyOptions = null;
+    const createCustomAdapter = (getDb)=>{
+        return ({ getFieldName })=>({
+                create: async ({ model, data })=>{
+                    const [row] = await getDb()(model).insert(data).returning("*");
+                    return row;
+                },
+                findOne: async ({ model, where })=>{
+                    let query = getDb()(model);
+                    query = applyWhere(query, where);
+                    const row = await query.first();
+                    return row ?? null;
+                },
+                findMany: async ({ model, where, limit, offset, sortBy })=>{
+                    let query = getDb()(model);
+                    if (where) {
+                        query = applyWhere(query, where);
+                    }
+                    if (sortBy) {
+                        const dbField = getFieldName({
+                            model,
+                            field: sortBy.field
+                        });
+                        query = query.orderBy(dbField, sortBy.direction);
+                    }
+                    if (limit) {
+                        query = query.limit(limit);
+                    }
+                    if (offset) {
+                        query = query.offset(offset);
+                    }
+                    return await query;
+                },
+                update: async ({ model, where, update })=>{
+                    let query = getDb()(model);
+                    query = applyWhere(query, where);
+                    const [row] = await query.update(update).returning("*");
+                    return row ?? null;
+                },
+                updateMany: async ({ model, where, update })=>{
+                    let query = getDb()(model);
+                    query = applyWhere(query, where);
+                    const count = await query.update(update);
+                    return count;
+                },
+                delete: async ({ model, where })=>{
+                    let query = getDb()(model);
+                    query = applyWhere(query, where);
+                    await query.del();
+                },
+                deleteMany: async ({ model, where })=>{
+                    let query = getDb()(model);
+                    query = applyWhere(query, where);
+                    const count = await query.del();
+                    return count;
+                },
+                count: async ({ model, where })=>{
+                    let query = getDb()(model);
+                    if (where) {
+                        query = applyWhere(query, where);
+                    }
+                    const [{ count }] = await query.count("* as count");
+                    return Number(count);
+                }
+            });
+    };
+    const adapterConfig = {
+        adapterId: "sonamu-knex",
+        adapterName: "Sonamu Knex Adapter",
+        usePlural: false,
+        supportsJSON: true,
+        supportsDates: true,
+        supportsBooleans: true,
+        supportsNumericIds: false,
+        transaction: async (cb)=>{
+            const db = DB.getDB("w");
+            return db.transaction(async (trx)=>{
+                const options = lazyOptions;
+                if (!options) {
+                    throw new Error("sonamuKnexAdapter: options not initialized");
+                }
+                return cb(createAdapterFactory({
+                    config: adapterConfig,
+                    adapter: createCustomAdapter(()=>trx)
+                })(options));
+            });
+        }
+    };
+    const adapterCreator = createAdapterFactory({
+        config: adapterConfig,
+        adapter: createCustomAdapter(()=>DB.getDB("w"))
+    });
+    return (options)=>{
+        lazyOptions = options;
+        return adapterCreator(options);
+    };
+};
+/**
+ * Better Auth의 공식 어댑터(Kysely, Drizzle, Prisma, MongoDB) 패턴에 맞춰
+ * AND 그룹과 OR 그룹을 분리한 뒤 top-level AND로 결합합니다.
+ * 결과: (A AND B AND ...) AND (C OR D OR ...)
+ */ export function applyWhere(query, conditions) {
+    const andGroup = conditions.filter((c)=>c.connector !== "OR");
+    const orGroup = conditions.filter((c)=>c.connector === "OR");
+    if (andGroup.length > 0) {
+        for (const condition of andGroup){
+            query = applyCondition(query, condition, "where");
+        }
+    }
+    if (orGroup.length > 0) {
+        query = query.where(function() {
+            for(let i = 0; i < orGroup.length; i++){
+                applyCondition(this, orGroup[i], i === 0 ? "where" : "orWhere");
+            }
+        });
+    }
+    return query;
+}
+function applyCondition(query, condition, method) {
+    const { field, value, operator } = condition;
+    switch(operator){
+        case "eq":
+            if (value === null) {
+                return query[method === "orWhere" ? "orWhereNull" : "whereNull"](field);
+            }
+            return query[method](field, "=", value);
+        case "ne":
+            if (value === null) {
+                return query[method === "orWhere" ? "orWhereNotNull" : "whereNotNull"](field);
+            }
+            return query[method](field, "!=", value);
+        case "lt":
+            return query[method](field, "<", value);
+        case "lte":
+            return query[method](field, "<=", value);
+        case "gt":
+            return query[method](field, ">", value);
+        case "gte":
+            return query[method](field, ">=", value);
+        case "in":
+            return query[method === "orWhere" ? "orWhereIn" : "whereIn"](field, value);
+        case "not_in":
+            return query[method === "orWhere" ? "orWhereNotIn" : "whereNotIn"](field, value);
+        case "contains":
+            return query[method](field, "like", `%${value}%`);
+        case "starts_with":
+            return query[method](field, "like", `${value}%`);
+        case "ends_with":
+            return query[method](field, "like", `%${value}`);
+        default:
+            return query;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/auth/knex-adapter.ts"],"sourcesContent":["import type { BetterAuthOptions } from \"better-auth\";\nimport type {\n  AdapterFactoryCustomizeAdapterCreator,\n  DBTransactionAdapter,\n} from \"better-auth/adapters\";\nimport { createAdapterFactory } from \"better-auth/adapters\";\nimport type { Knex } from \"knex\";\nimport { DB } from \"../database/db\";\n\ninterface CleanedWhere {\n  field: string;\n  value: string | number | boolean | string[] | number[] | Date | null;\n  operator: string;\n  connector: string;\n}\n\n/**\n * better-auth용 Sonamu knex 어댑터\n *\n * better-auth의 모든 쿼리를 DB.getDB()를 통해 실행하여\n * Sonamu 테스트 트랜잭션과 동일한 커넥션을 공유합니다.\n */\nexport const sonamuKnexAdapter = () => {\n  let lazyOptions: BetterAuthOptions | null = null;\n\n  const createCustomAdapter = (\n    getDb: () => Knex | Knex.Transaction,\n  ): AdapterFactoryCustomizeAdapterCreator => {\n    return ({ getFieldName }) => ({\n      create: async ({ model, data }) => {\n        const [row] = await getDb()(model).insert(data).returning(\"*\");\n        return row;\n      },\n\n      findOne: async ({ model, where }) => {\n        let query = getDb()(model);\n        query = applyWhere(query, where);\n        const row = await query.first();\n        return row ?? null;\n      },\n\n      findMany: async ({ model, where, limit, offset, sortBy }) => {\n        let query = getDb()(model);\n        if (where) {\n          query = applyWhere(query, where);\n        }\n        if (sortBy) {\n          const dbField = getFieldName({ model, field: sortBy.field });\n          query = query.orderBy(dbField, sortBy.direction);\n        }\n        if (limit) {\n          query = query.limit(limit);\n        }\n        if (offset) {\n          query = query.offset(offset);\n        }\n        return await query;\n      },\n\n      update: async ({ model, where, update }) => {\n        let query = getDb()(model);\n        query = applyWhere(query, where);\n        const [row] = await query.update(update).returning(\"*\");\n        return row ?? null;\n      },\n\n      updateMany: async ({ model, where, update }) => {\n        let query = getDb()(model);\n        query = applyWhere(query, where);\n        const count = await query.update(update);\n        return count;\n      },\n\n      delete: async ({ model, where }) => {\n        let query = getDb()(model);\n        query = applyWhere(query, where);\n        await query.del();\n      },\n\n      deleteMany: async ({ model, where }) => {\n        let query = getDb()(model);\n        query = applyWhere(query, where);\n        const count = await query.del();\n        return count;\n      },\n\n      count: async ({ model, where }) => {\n        let query = getDb()(model);\n        if (where) {\n          query = applyWhere(query, where);\n        }\n        const [{ count }] = await query.count(\"* as count\");\n        return Number(count);\n      },\n    });\n  };\n\n  const adapterConfig = {\n    adapterId: \"sonamu-knex\",\n    adapterName: \"Sonamu Knex Adapter\",\n    usePlural: false,\n    supportsJSON: true,\n    supportsDates: true,\n    supportsBooleans: true,\n    supportsNumericIds: false,\n    transaction: async <R>(cb: (trx: DBTransactionAdapter) => Promise<R>): Promise<R> => {\n      const db = DB.getDB(\"w\");\n      return db.transaction(async (trx) => {\n        const options = lazyOptions;\n        if (!options) {\n          throw new Error(\"sonamuKnexAdapter: options not initialized\");\n        }\n        return cb(\n          createAdapterFactory({\n            config: adapterConfig,\n            adapter: createCustomAdapter(() => trx),\n          })(options),\n        );\n      });\n    },\n  };\n\n  const adapterCreator = createAdapterFactory({\n    config: adapterConfig,\n    adapter: createCustomAdapter(() => DB.getDB(\"w\")),\n  });\n\n  return (options: BetterAuthOptions) => {\n    lazyOptions = options;\n    return adapterCreator(options);\n  };\n};\n\n/**\n * Better Auth의 공식 어댑터(Kysely, Drizzle, Prisma, MongoDB) 패턴에 맞춰\n * AND 그룹과 OR 그룹을 분리한 뒤 top-level AND로 결합합니다.\n * 결과: (A AND B AND ...) AND (C OR D OR ...)\n */\nexport function applyWhere(\n  query: Knex.QueryBuilder,\n  conditions: CleanedWhere[],\n): Knex.QueryBuilder {\n  const andGroup = conditions.filter((c) => c.connector !== \"OR\");\n  const orGroup = conditions.filter((c) => c.connector === \"OR\");\n\n  if (andGroup.length > 0) {\n    for (const condition of andGroup) {\n      query = applyCondition(query, condition, \"where\");\n    }\n  }\n\n  if (orGroup.length > 0) {\n    query = query.where(function (this: Knex.QueryBuilder) {\n      for (let i = 0; i < orGroup.length; i++) {\n        applyCondition(this, orGroup[i], i === 0 ? \"where\" : \"orWhere\");\n      }\n    });\n  }\n\n  return query;\n}\n\nfunction applyCondition(\n  query: Knex.QueryBuilder,\n  condition: CleanedWhere,\n  method: \"where\" | \"orWhere\",\n): Knex.QueryBuilder {\n  const { field, value, operator } = condition;\n\n  switch (operator) {\n    case \"eq\":\n      if (value === null) {\n        return query[method === \"orWhere\" ? \"orWhereNull\" : \"whereNull\"](field);\n      }\n      return query[method](field, \"=\", value);\n    case \"ne\":\n      if (value === null) {\n        return query[method === \"orWhere\" ? \"orWhereNotNull\" : \"whereNotNull\"](field);\n      }\n      return query[method](field, \"!=\", value);\n    case \"lt\":\n      return query[method](field, \"<\", value);\n    case \"lte\":\n      return query[method](field, \"<=\", value);\n    case \"gt\":\n      return query[method](field, \">\", value);\n    case \"gte\":\n      return query[method](field, \">=\", value);\n    case \"in\":\n      return query[method === \"orWhere\" ? \"orWhereIn\" : \"whereIn\"](\n        field,\n        value as (string | number)[],\n      );\n    case \"not_in\":\n      return query[method === \"orWhere\" ? \"orWhereNotIn\" : \"whereNotIn\"](\n        field,\n        value as (string | number)[],\n      );\n    case \"contains\":\n      return query[method](field, \"like\", `%${value}%`);\n    case \"starts_with\":\n      return query[method](field, \"like\", `${value}%`);\n    case \"ends_with\":\n      return query[method](field, \"like\", `%${value}`);\n    default:\n      return query;\n  }\n}\n"],"names":["createAdapterFactory","DB","sonamuKnexAdapter","lazyOptions","createCustomAdapter","getDb","getFieldName","create","model","data","row","insert","returning","findOne","where","query","applyWhere","first","findMany","limit","offset","sortBy","dbField","field","orderBy","direction","update","updateMany","count","delete","del","deleteMany","Number","adapterConfig","adapterId","adapterName","usePlural","supportsJSON","supportsDates","supportsBooleans","supportsNumericIds","transaction","cb","db","getDB","trx","options","Error","config","adapter","adapterCreator","conditions","andGroup","filter","c","connector","orGroup","length","condition","applyCondition","i","method","value","operator"],"mappings":"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"}

package/dist/auth/plugins/wrappers/admin.d.ts

@@ -723,13 +723,13 @@ export declare const admin: (options?: AdminOptions) => {
                 $Infer: {
                     body: ({
                         permission: {
-                            readonly user?: ("update" | "delete" | "list" | "get" | "create" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                            readonly user?: ("update" | "delete" | "list" | "create" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
                             readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                         };
                         permissions?: never | undefined;
                     } | {
                         permissions: {
-                            readonly user?: ("update" | "delete" | "list" | "get" | "create" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                            readonly user?: ("update" | "delete" | "list" | "create" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
                             readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                         };
                         permission?: never | undefined;

package/dist/bin/__tests__/ts-loader-register.test.js

@@ -0,0 +1,45 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+const tsLoaderRegisterStateKey = Symbol.for("sonamu.ts-loader-register.state");
+function resetRegisterState() {
+    const globalState = globalThis;
+    delete globalState[tsLoaderRegisterStateKey];
+    delete process.env.SWCRC_PATH;
+}
+describe("ensureTsLoaderRegistered", ()=>{
+    beforeEach(()=>{
+        vi.resetModules();
+        vi.restoreAllMocks();
+        vi.unmock("node:module");
+        vi.unmock("../../utils/fs-utils.js");
+        resetRegisterState();
+    });
+    afterEach(()=>{
+        vi.resetModules();
+        vi.restoreAllMocks();
+        vi.unmock("node:module");
+        vi.unmock("../../utils/fs-utils.js");
+        resetRegisterState();
+    });
+    it("프로젝트 .swcrc를 우선 사용하고 중복 등록하지 않는다", async ()=>{
+        const registerMock = vi.fn();
+        vi.doMock("node:module", ()=>({
+                register: registerMock
+            }));
+        vi.doMock("../../utils/fs-utils.js", ()=>({
+                exists: vi.fn(async (candidate)=>candidate === "/tmp/fixture-api/.swcrc")
+            }));
+        const module = await import("../ts-loader-registration.js");
+        expect(registerMock).not.toHaveBeenCalled();
+        await module.ensureTsLoaderRegistered("/tmp/fixture-api");
+        expect(registerMock).toHaveBeenCalledTimes(1);
+        expect(registerMock).toHaveBeenCalledWith("@sonamu-kit/ts-loader/loader", {
+            parentURL: expect.stringContaining("/src/bin/ts-loader-registration")
+        });
+        expect(process.env.SWCRC_PATH).toBe("/tmp/fixture-api/.swcrc");
+        await module.ensureTsLoaderRegistered("/tmp/another-api");
+        expect(registerMock).toHaveBeenCalledTimes(1);
+        expect(process.env.SWCRC_PATH).toBe("/tmp/fixture-api/.swcrc");
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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