@gencow/core 0.1.12 → 0.1.14

package/src/__tests__/dist-exports.test.ts

@@ -0,0 +1,170 @@
+/**
+ * packages/core/src/__tests__/dist-exports.test.ts
+ *
+ * dist/ 빌드 산출물의 필수 export 검증 — npm publish 전 안전망.
+ *
+ * 이 테스트의 존재 이유:
+ *   2026-04-02 사고: 소스코드에 crud v2가 완전 구현되어 있었으나,
+ *   dist/index.js에 `crud` export가 누락된 구버전이 npm에 배포됨.
+ *   crud.test.ts(16 pass)가 src/crud.ts를 직접 import하므로
+ *   dist/ 빌드 결과물의 정합성은 검증하지 못했음.
+ *
+ * 검증 항목:
+ *   1. dist/index.js 파일 존재
+ *   2. 필수 named export 존재 (crud, query, mutation, v, ...)
+ *   3. gencowCrud deprecated alias 존재 (하위호환)
+ *   4. crud가 실제 함수인지 (typeof === "function")
+ *   5. dist/index.js의 crud와 src/crud.ts의 crud가 동일 함수인지
+ *
+ * Run: bun test packages/core/src/__tests__/dist-exports.test.ts
+ *
+ * @see docs/analysis/analysis-test032-gencow-crud-api-mismatch.md
+ */
+
+import { describe, it, expect } from "bun:test";
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CORE_ROOT = resolve(__dirname, "../..");
+const DIST_INDEX = resolve(CORE_ROOT, "dist/index.js");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 1. dist/ 파일 존재 확인
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("dist/ 빌드 산출물 존재", () => {
+    it("dist/index.js 파일이 존재한다", () => {
+        expect(existsSync(DIST_INDEX)).toBe(true);
+    });
+
+    it("dist/crud.js 파일이 존재한다", () => {
+        expect(existsSync(resolve(CORE_ROOT, "dist/crud.js"))).toBe(true);
+    });
+
+    it("dist/reactive.js 파일이 존재한다", () => {
+        expect(existsSync(resolve(CORE_ROOT, "dist/reactive.js"))).toBe(true);
+    });
+
+    it("dist/v.js 파일이 존재한다", () => {
+        expect(existsSync(resolve(CORE_ROOT, "dist/v.js"))).toBe(true);
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 2. 필수 named export 존재 확인
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("dist/index.js 필수 export", () => {
+    let distModule: Record<string, unknown>;
+
+    // dist/index.js를 dynamic import (빌드 결과물 검증)
+    it("dist/index.js를 import할 수 있다", async () => {
+        distModule = await import(DIST_INDEX);
+        expect(distModule).toBeDefined();
+    });
+
+    // ── Core API exports ──────────────────────────────────────
+
+    it("crud export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.crud).toBeDefined();
+        expect(typeof distModule.crud).toBe("function");
+    });
+
+    it("gencowCrud deprecated alias가 존재하고 crud와 동일하다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.gencowCrud).toBeDefined();
+        expect(distModule.gencowCrud).toBe(distModule.crud);
+    });
+
+    it("query export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.query).toBeDefined();
+        expect(typeof distModule.query).toBe("function");
+    });
+
+    it("mutation export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.mutation).toBeDefined();
+        expect(typeof distModule.mutation).toBe("function");
+    });
+
+    it("v export가 존재하고 객체이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.v).toBeDefined();
+        expect(typeof distModule.v).toBe("object");
+    });
+
+    it("httpAction export가 존재하고 함수이다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.httpAction).toBeDefined();
+        expect(typeof distModule.httpAction).toBe("function");
+    });
+
+    // ── Registry exports (codegen 의존) ────────────────────────
+
+    it("getRegisteredQueries export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.getRegisteredQueries).toBeDefined();
+        expect(typeof distModule.getRegisteredQueries).toBe("function");
+    });
+
+    it("getRegisteredMutations export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.getRegisteredMutations).toBeDefined();
+        expect(typeof distModule.getRegisteredMutations).toBe("function");
+    });
+
+    // ── RLS + Auth exports ─────────────────────────────────────
+
+    it("ownerRls export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.ownerRls).toBeDefined();
+    });
+
+    it("defineAuth export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.defineAuth).toBeDefined();
+    });
+
+    it("cronJobs export가 존재한다", async () => {
+        if (!distModule) distModule = await import(DIST_INDEX);
+        expect(distModule.cronJobs).toBeDefined();
+    });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 3. dist/crud.js가 v2 구현인지 확인 (커링 구조가 아닌지)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("dist/crud.js — v2 구현 검증", () => {
+    it("crud(table) 시그니처이다 (커링 gencowCrud(db)(table) 아님)", async () => {
+        const distModule = await import(DIST_INDEX);
+        const { crud } = distModule;
+
+        // v2: crud(table, options?) → { list, get, create, update, remove }
+        // 구버전: gencowCrud(db) → (table, options?) → { create, findById, list, ... }
+
+        // 실제 Drizzle 테이블로 테스트
+        const { pgTable, serial, text } = await import("drizzle-orm/pg-core");
+        const testTable = pgTable("dist_smoke_test", {
+            id: serial("id").primaryKey(),
+            name: text("name"),
+        });
+
+        const result = crud(testTable, { public: true });
+
+        // v2는 { list, get, create, update, remove } 반환
+        expect(result).toHaveProperty("list");
+        expect(result).toHaveProperty("get");
+        expect(result).toHaveProperty("create");
+        expect(result).toHaveProperty("update");
+        expect(result).toHaveProperty("remove");
+
+        // 구버전(커링)은 함수를 반환하므로 이 검증이 실패함
+        expect(typeof result).toBe("object");
+        expect(typeof result.list).not.toBe("undefined");
+    });
+});

package/src/__tests__/scheduler-exec.test.ts

@@ -142,17 +142,17 @@ describe("Scheduler 실행 — registerAction + executeAction", () => {
         expect(result).toBe("Hello World");
     });
 
-    it("미등록 action executeAction → 에러를 throw한다", async () => {
+    it("미등록 action executeAction → throw 안 함, console.error 출력", async () => {
         const scheduler = createScheduler();
-        // 미등록 action은 에러를 throw해야 함
-        let threw = false;
-        try {
-            await scheduler.executeAction("nonexistent");
-        } catch (e) {
-            threw = true;
-            expect((e as Error).message).toContain("not registered");
-        }
-        expect(threw).toBe(true);
+        // 공개 API는 에러를 삼기고 console.error만 출력
+        const errors: string[] = [];
+        const origError = console.error;
+        console.error = (...args: any[]) => { errors.push(args.map(String).join(" ")); };
+
+        await scheduler.executeAction("nonexistent"); // throw하지 않음
+
+        console.error = origError;
+        expect(errors.some(e => e.includes("nonexistent"))).toBe(true);
     });
 
     it("action 에러 시 다른 action에 영향 없음", async () => {
@@ -166,14 +166,11 @@ describe("Scheduler 실행 — registerAction + executeAction", () => {
             secondRan = true;
         });
 
-        // 실패하는 action — 에러를 throw함
-        let threw = false;
-        try {
-            await scheduler.executeAction("failing");
-        } catch {
-            threw = true;
-        }
-        expect(threw).toBe(true);
+        // 실패하는 action — 공개 API는 throw하지 않음 (에러를 삼김)
+        const origError = console.error;
+        console.error = () => {}; // suppress expected error log
+        await scheduler.executeAction("failing"); // throw하지 않음
+        console.error = origError;
 
         // 정상 action은 여전히 동작
         await scheduler.executeAction("healthy");

package/src/crud.ts

@@ -1,174 +1,323 @@
-import { eq, or, and, ilike, desc, asc, inArray, count, sql, type SQL } from "drizzle-orm";
-import type { PgDatabase, PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
+/**
+ * packages/core/src/crud.ts — Zero-Boilerplate CRUD API Auto-Generator (v2)
+ *
+ * 사용자 코드 5줄로 완전한 CRUD API를 자동 생성:
+ *
+ * @example
+ * ```ts
+ * import { crud } from "@gencow/core";
+ * import { tasks } from "./schema";
+ *
+ * // query(tasks.list), query(tasks.get), mutation(tasks.create/update/remove) 자동 등록
+ * export const { list, get, create, update, remove } = crud(tasks);
+ * ```
+ *
+ * list 반환값: `{ data: T[], total: number }`
+ *   → 프론트: `const result = useQuery(api.tasks.list); result?.data.map(...)`
+ *   → total은 동일 필터 조건의 전체 레코드 수 (페이지네이션 UI 지원)
+ *
+ * 내부적으로 query()/mutation()을 호출하여 글로벌 레지스트리에 등록하므로,
+ * 프론트엔드에서 useQuery(api.tasks.list) / useMutation(api.tasks.create) 로 바로 사용 가능.
+ *
+ * 📄 Spec: docs/specs/spec-crud-v2-enhancements.md
+ * 📦 참조: saas-js/drizzle-crud 팩토리 패턴
+ */
+
+import { eq, desc, asc, ilike, or, and, count as drizzleCount, getTableName, getTableColumns, type SQL } from "drizzle-orm";
+import type { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
+import { query, mutation } from "./reactive";
+import { v } from "./v";
+
+// ─── Types ──────────────────────────────────────────────
 
 type CrudOptions<T extends PgTable> = {
+    /** 검색 대상 필드 — list의 search 파라미터에 사용 */
     searchFields?: (keyof T["_"]["columns"])[];
+    /** 소프트 삭제 컬럼 (e.g. deletedAt) */
     softDelete?: { field: keyof T["_"]["columns"] };
+    /** 필터링 허용 필드 — allowedFilters에 없는 키는 무시 (보안) */
     allowedFilters?: (keyof T["_"]["columns"])[];
+    /** 기본 페이지 크기 (default: 20) */
     defaultLimit?: number;
+    /** 최대 페이지 크기 (default: 100) */
     maxLimit?: number;
+    /** 라이프사이클 훅 */
     hooks?: {
         beforeCreate?: (data: any) => any | Promise<any>;
         beforeUpdate?: (data: any) => any | Promise<any>;
     };
+    /** true면 인증 없이 접근 가능 (기본: false — Secure by Default) */
+    public?: boolean;
+    /** true면 mutation 후 realtime push (기본: true) */
+    realtime?: boolean;
+    /** 키 접두사 오버라이드 (기본: 테이블명) */
+    prefix?: string;
 };
 
-export function gencowCrud(db: PgDatabase<any, any, any>) {
-    return function createCrud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
-        const anyTable = table as any;
-        const pk = anyTable["id"] as AnyPgColumn;
-        
-        if (!pk) {
-            throw new Error(`[gencowCrud] Table ${anyTable["_"]["name"]} must have an 'id' column.`);
+// ─── Helpers ────────────────────────────────────────────
+
+/**
+ * id 컬럼의 Drizzle dataType을 검사하여 적절한 validator를 반환.
+ * serial/integer/bigint → v.number()
+ * text/uuid/varchar → v.string()
+ */
+function detectIdType(column: AnyPgColumn) {
+    const colType = (column as any).dataType;
+    if (colType === "string") return v.string();
+    return v.number();
+}
+
+// ─── crud — Zero-Boilerplate API Factory ──────────
+
+/**
+ * 테이블을 받아 query/mutation을 자동 등록하고,
+ * { list, get, create, update, remove } 를 반환한다.
+ *
+ * list 반환값: `{ data: T[], total: number }`
+ *
+ * @example
+ * ```ts
+ * export const { list, get, create, update, remove } = crud(tasks);
+ * export const { list, get, create, update, remove } = crud(tasks, { public: true });
+ * ```
+ */
+export function crud<T extends PgTable>(table: T, options?: CrudOptions<T>) {
+    const anyTable = table as any;
+    const tableName: string = getTableName(table); // Drizzle 공식 API
+    const prefix = options?.prefix || tableName;
+    const isPublic = options?.public ?? false;
+    const useRealtime = options?.realtime ?? true;
+    const defaultLimit = options?.defaultLimit ?? 20;
+    const maxLimit = options?.maxLimit ?? 100;
+    const pk = anyTable["id"] as AnyPgColumn;
+
+    if (!pk) {
+        throw new Error(`[crud] Table "${tableName}" must have an 'id' column.`);
+    }
+
+    // id 타입 자동 감지 (serial → v.number(), text/uuid → v.string())
+    const idValidator = detectIdType(pk);
+
+    // createdAt 컬럼 (정렬용, 없으면 id 사용)
+    const createdAtCol = anyTable["createdAt"] as AnyPgColumn | undefined;
+    const defaultOrderCol = createdAtCol || pk;
+
+    // userId 컬럼 (자동 주입용)
+    const userIdCol = anyTable["userId"] as AnyPgColumn | undefined;
+
+    // ── 내부 헬퍼: WHERE 조건 빌드 (list + count + realtime 공유) ──
+    function buildWhereConditions(args: any): SQL | undefined {
+        const conditions: SQL[] = [];
+
+        // Soft delete
+        if (options?.softDelete) {
+            const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
+            conditions.push(eq(sdField, null as any));
         }
-        
-        async function create(data: any): Promise<any> {
-            let insertData = { ...data };
-            if (options?.hooks?.beforeCreate) {
-                insertData = await options.hooks.beforeCreate(insertData);
-            }
-            const [result] = await db.insert(anyTable).values(insertData).returning();
-            return result;
+
+        // Search
+        if (args?.search && options?.searchFields?.length) {
+            const searchConds = options.searchFields.map(
+                (f) => ilike(anyTable[f as string] as AnyPgColumn, `%${args.search}%`)
+            );
+            conditions.push(or(...searchConds)!);
         }
 
-        async function findById(id: any): Promise<any | null> {
-            let whereCond: SQL | undefined = eq(pk, id);
-            
-            if (options?.softDelete) {
-                const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
-                whereCond = and(whereCond, sql`${sdField} IS NULL`);
+        // Dynamic filters (allowedFilters 화이트리스트만 허용)
+        if (args?.filters && options?.allowedFilters?.length) {
+            for (const [key, value] of Object.entries(args.filters as Record<string, unknown>)) {
+                if (options.allowedFilters.includes(key as any) && anyTable[key]) {
+                    conditions.push(eq(anyTable[key] as AnyPgColumn, value));
+                }
+                // allowedFilters에 없는 키는 무시 (보안)
             }
-            
-            const [result] = await db.select().from(anyTable).where(whereCond).limit(1);
-            return result || null;
         }
 
-        async function list(params?: {
-            page?: number;
-            limit?: number;
-            search?: string;
-            filters?: Record<string, any>;
-            orderBy?: { field: string; direction: 'asc' | 'desc' }[];
-            includeDeleted?: boolean;
-        }) {
-            const page = Math.max(1, params?.page || 1);
-            const limit = Math.min(
-                Math.max(1, params?.limit || options?.defaultLimit || 20),
-                options?.maxLimit || 100
-            );
-            const offset = (page - 1) * limit;
+        return conditions.length > 0 ? and(...conditions) : undefined;
+    }
 
-            const conditions: SQL[] = [];
+    // ── 내부 헬퍼: list+count 데이터 가져오기 (realtime push용 재사용) ──
+    // 순차 실행: 소규모 커넥션 풀 환경에서 동시 점유 방지
+    // ⚠️ limit/offset 없이 전체 SELECT — 대량 데이터 시 성능 저하 주의
+    // TODO(P2): realtime emit 시 invalidation 메시지만 전송하고 클라이언트가 re-fetch하는 패턴 검토
+    async function fetchListWithTotal(db: any, whereClause?: SQL) {
+        const data = await db.select().from(anyTable).where(whereClause).orderBy(desc(defaultOrderCol));
+        const countResult = await db.select({ count: drizzleCount() }).from(anyTable).where(whereClause);
+        return { data, total: Number(countResult[0]?.count ?? 0) };
+    }
 
-            // Soft delete
-            if (options?.softDelete && !params?.includeDeleted) {
-               conditions.push(sql`${anyTable[options.softDelete.field as string]} IS NULL`);
-            }
+    // ── list ──────────────────────────────────────
 
-            // Search
-            if (params?.search && options?.searchFields?.length) {
-                const searchConds = options.searchFields.map(
-                    (f) => ilike(anyTable[f as string] as AnyPgColumn, `%${params!.search}%`)
-                );
-                conditions.push(or(...searchConds)!);
-            }
+    const listDef = query(`${prefix}.list`, {
+        public: isPublic,
+        args: {
+            page: v.optional(v.number()),
+            limit: v.optional(v.number()),
+            search: v.optional(v.string()),
+            orderBy: v.optional(v.string()),
+            orderDir: v.optional(v.string()),
+            filters: v.optional(v.any()),
+        },
+        handler: async (ctx: any, args: any) => {
+            if (!isPublic) ctx.auth.requireAuth();
 
-            // Filters
-            if (params?.filters && options?.allowedFilters) {
-                for (const [k, v] of Object.entries(params.filters)) {
-                    if (options.allowedFilters.includes(k as keyof T["_"]["columns"])) {
-                        conditions.push(eq(anyTable[k] as AnyPgColumn, v));
-                    }
-                }
+            const page = Math.max(1, args?.page || 1);
+            const limit = Math.min(Math.max(1, args?.limit || defaultLimit), maxLimit);
+            const offset = (page - 1) * limit;
+
+            const whereClause = buildWhereConditions(args);
+
+            // Order
+            let orderByClause;
+            if (args?.orderBy && anyTable[args.orderBy]) {
+                const col = anyTable[args.orderBy] as AnyPgColumn;
+                orderByClause = args.orderDir === "asc" ? asc(col) : desc(col);
+            } else {
+                orderByClause = desc(defaultOrderCol);
             }
 
-            const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
-
-            // Order By
-            const orderByArgs = (params?.orderBy || []).map((o) => {
-                const col = anyTable[o.field] as AnyPgColumn;
-                return o.direction === 'desc' ? desc(col) : asc(col);
-            });
-            
-            // Base count 
-            const [{ count: total }] = await db.select({ count: count() }).from(anyTable).where(whereClause);
-            
-            const results = await db.select()
+            // SELECT + COUNT 순차 실행 — 소규모 커넥션 풀 환경에서 동시 점유 방지
+            // Note: data←→count 사이 INSERT/DELETE 시 total 불일치 가능 (BaaS 단일사용자/저부하에서 무시 가능)
+            // TODO(P2): 대규모 시 db.transaction() 래핑 검토
+            const results = await ctx.db.select()
                 .from(anyTable)
                 .where(whereClause)
-                .orderBy(...orderByArgs)
+                .orderBy(orderByClause)
                 .limit(limit)
                 .offset(offset);
+            const countResult = await ctx.db.select({ count: drizzleCount() })
+                .from(anyTable)
+                .where(whereClause);
 
             return {
-                results,
-                page,
-                limit,
-                total: Number(total),
+                data: results,
+                total: Number(countResult[0]?.count ?? 0),
             };
         }
+    });
+
+    // ── get ───────────────────────────────────────
+
+    const getDef = query(`${prefix}.get`, {
+        public: isPublic,
+        args: { id: idValidator },
+        handler: async (ctx: any, args: any) => {
+            if (!isPublic) ctx.auth.requireAuth();
+
+            let whereCond: SQL = eq(pk, args.id);
+
+            if (options?.softDelete) {
+                const sdField = anyTable[options.softDelete.field as string] as AnyPgColumn;
+                whereCond = and(whereCond, eq(sdField, null as any))!;
+            }
+
+            const [result] = await ctx.db.select().from(anyTable).where(whereCond).limit(1);
+            return result ?? null;
+        }
+    });
 
-        async function update(id: any, data: any): Promise<any> {
-            let updateData = { ...data };
+    // ── create ────────────────────────────────────
+
+    const createDef = mutation(`${prefix}.create`, {
+        public: isPublic,
+        invalidates: [],
+        handler: async (ctx: any, args: any) => {
+            const user = isPublic ? null : ctx.auth.requireAuth();
+
+            let insertData = { ...args };
+
+            // userId 자동 주입 (테이블에 userId 컬럼이 있고 인증된 경우)
+            if (userIdCol && user && !insertData.userId) {
+                insertData.userId = user.id;
+            }
+
+            // beforeCreate 훅
+            if (options?.hooks?.beforeCreate) {
+                insertData = await options.hooks.beforeCreate(insertData);
+            }
+
+            const [result] = await ctx.db.insert(anyTable).values(insertData).returning();
+
+            // Realtime push — { data, total } 형태로 emit
+            if (useRealtime) {
+                const listResult = await fetchListWithTotal(ctx.db);
+                ctx.realtime.emit(`${prefix}.list`, listResult);
+            }
+
+            return result;
+        }
+    });
+
+    // ── update ────────────────────────────────────
+
+    const updateDef = mutation(`${prefix}.update`, {
+        public: isPublic,
+        invalidates: [],
+        handler: async (ctx: any, args: any) => {
+            if (!isPublic) ctx.auth.requireAuth();
+
+            const { id, ...updates } = args;
+
+            let updateData = { ...updates };
+
+            // updatedAt 자동 갱신
+            if (anyTable["updatedAt"]) {
+                updateData.updatedAt = new Date();
+            }
+
+            // beforeUpdate 훅
             if (options?.hooks?.beforeUpdate) {
                 updateData = await options.hooks.beforeUpdate(updateData);
             }
-            const [result] = await db.update(anyTable)
+
+            const [result] = await ctx.db.update(anyTable)
                 .set(updateData)
                 .where(eq(pk, id))
                 .returning();
-            return result;
-        }
 
-        async function deleteOne(id: any): Promise<void> {
-            if (options?.softDelete) {
-                const sdField = options.softDelete.field as string;
-                await db.update(anyTable)
-                    .set({ [sdField]: new Date() } as any)
-                    .where(eq(pk, id));
-            } else {
-                await db.delete(anyTable).where(eq(pk, id));
+            // Realtime push (list + get 양쪽) — { data, total } 형태
+            if (useRealtime) {
+                const listResult = await fetchListWithTotal(ctx.db);
+                ctx.realtime.emit(`${prefix}.list`, listResult);
+                ctx.realtime.emit(`${prefix}.get`, result);
             }
-        }
 
-        async function restore(id: any): Promise<void> {
-            if (options?.softDelete) {
-                const sdField = options.softDelete.field as string;
-                await db.update(anyTable)
-                    .set({ [sdField]: null } as any)
-                    .where(eq(pk, id));
-            }
+            return result;
         }
+    });
 
-        async function bulkCreate(dataArray: any[]): Promise<any[]> {
-            let insertData = [...dataArray];
-            if (options?.hooks?.beforeCreate) {
-                insertData = await Promise.all(insertData.map((d) => options.hooks!.beforeCreate!(d)));
-            }
-            return await db.insert(anyTable).values(insertData).returning();
-        }
+    // ── remove ────────────────────────────────────
+
+    const removeDef = mutation(`${prefix}.remove`, {
+        public: isPublic,
+        invalidates: [],
+        handler: async (ctx: any, args: any) => {
+            if (!isPublic) ctx.auth.requireAuth();
 
-        async function bulkDelete(ids: any[]): Promise<void> {
-            if (ids.length === 0) return;
             if (options?.softDelete) {
                 const sdField = options.softDelete.field as string;
-                await db.update(anyTable)
+                await ctx.db.update(anyTable)
                     .set({ [sdField]: new Date() } as any)
-                    .where(inArray(pk, ids));
+                    .where(eq(pk, args.id));
             } else {
-                await db.delete(anyTable).where(inArray(pk, ids));
+                await ctx.db.delete(anyTable).where(eq(pk, args.id));
             }
+
+            // Realtime push — { data, total } 형태
+            if (useRealtime) {
+                const listResult = await fetchListWithTotal(ctx.db);
+                ctx.realtime.emit(`${prefix}.list`, listResult);
+            }
+
+            return { success: true };
         }
+    });
 
-        return {
-            create,
-            findById,
-            list,
-            update,
-            deleteOne,
-            restore,
-            bulkCreate,
-            bulkDelete,
-        };
+    return {
+        list: listDef,
+        get: getDef,
+        create: createDef,
+        update: updateDef,
+        remove: removeDef,
     };
 }