@ai0x0/utils 0.0.46 → 0.0.48

package/lib/backend/route-operation/post-operation.js

@@ -32,81 +32,17 @@ __export(post_operation_exports, {
   createPostOperation: () => createPostOperation
 });
 module.exports = __toCommonJS(post_operation_exports);
-var import_zod = require("zod");
-var import_next_rest_framework = require("next-rest-framework");
+var import_create_post_action = require("../actions/create-post-action");
 var import_get_table_name = __toESM(require("./get-table-name"));
-var import_actions = require("../actions");
-async function readPostBody(req, {
-  contentType,
-  parseBody
-}) {
-  if (parseBody) {
-    return parseBody(req);
-  }
-  if (contentType === "multipart/form-data") {
-    return Object.fromEntries(await req.formData());
-  }
-  return await req.json();
-}
+var import_operation_core = require("./operation-core");
+var createOperation = (0, import_operation_core.createPostOperationFactory)({
+  createAction: import_create_post_action.createPostAction,
+  getTableName: import_get_table_name.default
+});
 var createPostOperation = ({
   getSession,
   db
-}) => ({
-  bodySchema,
-  contentType = "application/json",
-  description,
-  outputBodySchema,
-  parseBody,
-  setBody,
-  summary,
-  tags,
-  table,
-  onSuccess,
-  onError
-}) => (0, import_next_rest_framework.routeOperation)({
-  method: "POST",
-  openApiOperation: {
-    description,
-    summary,
-    tags: tags ?? (table ? [(0, import_get_table_name.default)(table)] : [])
-  }
-}).input({
-  body: bodySchema,
-  contentType
-}).outputs([
-  {
-    body: outputBodySchema || import_zod.z.object({ id: import_zod.z.string() }),
-    contentType: "application/json",
-    status: 200
-  }
-]).handler(async (req) => {
-  try {
-    const { userId } = await getSession(req) || {};
-    const body = await readPostBody(req, { contentType, parseBody });
-    const extraBody = await (setBody == null ? void 0 : setBody(req)) || {};
-    const mergedBody = { ...body, ...extraBody };
-    const params = { creatorId: userId, ...mergedBody };
-    const raw = table && db ? (await (0, import_actions.createPostAction)({ bodySchema, db, table })(
-      params
-    ))[0] : params;
-    const data = onSuccess ? await onSuccess({
-      data: raw,
-      params,
-      req
-    }) : raw;
-    return import_next_rest_framework.TypedNextResponse.json(data, {
-      status: 200
-    });
-  } catch (e) {
-    console.error(e);
-    const response = await (onError == null ? void 0 : onError(e));
-    if (response) {
-      return response;
-    } else {
-      throw e;
-    }
-  }
-});
+}) => createOperation({ db, getSession });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createPostOperation

package/lib/backend/route-operation/put-operation.d.ts

@@ -1,31 +1,12 @@
-import { z, ZodSchema } from "zod";
 import { PgTable } from "drizzle-orm/pg-core";
-import { TypedNextRequest, TypedNextResponse } from "next-rest-framework";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { NextRequest } from "next/server";
-import { BaseTable } from "../types.js";
-type PutOperationParams<IB extends ZodSchema> = z.infer<IB> & Record<string, unknown> & {
-    editorId?: string;
-};
-export interface PutOperationOptions<IB extends ZodSchema, OB extends ZodSchema, TTable extends PgTable> {
-    bodySchema: IB;
-    description?: string;
-    outputBodySchema?: OB;
-    table?: TTable;
-    summary?: string;
-    tags?: string[];
-    setBody?(req: TypedNextRequest<"PUT", "application/json", z.infer<IB>>): Promise<Partial<z.infer<IB>>>;
-    onSuccess?(payload: {
-        params: PutOperationParams<IB>;
-        data: z.infer<OB>;
-    }): Promise<z.infer<OB>>;
-    onError?(error: Error): Promise<ReturnType<(typeof TypedNextResponse)["json"]> | undefined>;
-    byCreator?: boolean;
-}
+import { ZodSchema } from "zod";
+import { type PutOperationOptions as CorePutOperationOptions } from "./operation-core.js";
+export type PutOperationOptions<IB extends ZodSchema, OB extends ZodSchema, TTable extends PgTable> = CorePutOperationOptions<IB, OB, TTable>;
 export declare const createPutOperation: ({ getSession, db, }: {
     getSession(req: NextRequest): Promise<{
         userId?: string;
     } | undefined>;
     db?: NodePgDatabase<Record<string, unknown>> | undefined;
-}) => <IB extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, OB extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, TTable extends BaseTable>({ bodySchema, description, outputBodySchema, table, summary, tags, setBody, onSuccess, byCreator, onError, }: PutOperationOptions<IB, OB, TTable>) => import("next-rest-framework").RouteOperationDefinition<"PUT">;
-export {};
+}) => <IB extends ZodSchema<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>, OB extends ZodSchema<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>({ schemas, access, openApiOperation, table, setBody, handler, catch: catchHandler, }: CorePutOperationOptions<IB, OB, PgTable<import("drizzle-orm/pg-core").TableConfig>>) => import("next-rest-framework").RouteOperationDefinition<"PUT">;

package/lib/backend/route-operation/put-operation.js

@@ -32,78 +32,17 @@ __export(put_operation_exports, {
   createPutOperation: () => createPutOperation
 });
 module.exports = __toCommonJS(put_operation_exports);
-var import_zod = require("zod");
-var import_next_rest_framework = require("next-rest-framework");
+var import_create_put_action = require("../actions/create-put-action");
 var import_get_table_name = __toESM(require("./get-table-name"));
-var import_actions = require("../actions");
-var import_errors = require("../errors");
+var import_operation_core = require("./operation-core");
+var createOperation = (0, import_operation_core.createPutOperationFactory)({
+  createAction: import_create_put_action.createPutAction,
+  getTableName: import_get_table_name.default
+});
 var createPutOperation = ({
   getSession,
   db
-}) => ({
-  bodySchema,
-  description,
-  outputBodySchema,
-  table,
-  summary,
-  tags,
-  setBody,
-  onSuccess,
-  byCreator = true,
-  onError
-}) => (0, import_next_rest_framework.routeOperation)({
-  method: "PUT",
-  openApiOperation: {
-    description,
-    summary,
-    tags: tags ?? (table ? [(0, import_get_table_name.default)(table)] : [])
-  }
-}).input({
-  body: bodySchema,
-  contentType: "application/json"
-}).outputs([
-  {
-    body: outputBodySchema || import_zod.z.void(),
-    status: 200,
-    contentType: "application/json"
-  }
-]).handler(async (req) => {
-  try {
-    const { userId } = await getSession(req) || {};
-    const body = await req.json();
-    const extraBody = await (setBody == null ? void 0 : setBody(
-      req
-    )) || {};
-    const mergedBody = { ...body, ...extraBody };
-    const params = { editorId: userId, ...mergedBody };
-    const raw = table && db ? await (0, import_actions.createPutAction)({
-      bodySchema,
-      table,
-      db
-    })(params, { byCreator }) : params;
-    const data = onSuccess ? await onSuccess({
-      data: raw,
-      params
-    }) : raw;
-    return import_next_rest_framework.TypedNextResponse.json(data, {
-      status: 200
-    });
-  } catch (e) {
-    if (!(e instanceof import_errors.HttpError)) {
-      console.error(e);
-    }
-    const response = await (onError == null ? void 0 : onError(e));
-    if (response) {
-      return response;
-    }
-    if (e instanceof import_errors.HttpError) {
-      return import_next_rest_framework.TypedNextResponse.json({ message: e.message }, {
-        status: e.status
-      });
-    }
-    throw e;
-  }
-});
+}) => createOperation({ db, getSession });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createPutOperation

package/lib/backend/route-operation/read-operation-core.d.ts

@@ -0,0 +1,55 @@
+import { NextRequest } from "next/server";
+import { TypedNextRequest } from "next-rest-framework";
+import { z, ZodSchema } from "zod";
+import { type RouteOpenApiOperation } from "./open-api-operation.js";
+import { ActionFactory, GetOperationParams, RouteCatch, SessionGetter } from "./operation-common.js";
+export interface GetOperationOptions<T extends ZodSchema, Q extends ZodSchema, TTable, TRelations> {
+    schemas: {
+        query: Q;
+        response: T;
+    };
+    access?: {
+        byCreator?: boolean;
+    };
+    jsonArrayFields?: string[];
+    relations?: TRelations;
+    setParams?: (_req: TypedNextRequest<"GET", "application/json", unknown, z.infer<Q>>) => Promise<Record<string, unknown>>;
+    handler?: (_payload: {
+        params: GetOperationParams<Q>;
+        data: z.infer<T>;
+        req: NextRequest;
+    }) => Promise<z.infer<T>>;
+    catch?: RouteCatch;
+    openApiOperation?: RouteOpenApiOperation;
+    table?: TTable;
+}
+export declare function createGetOperationFactory<TTable, TRelations>({ createAction, getTableName, }: {
+    createAction: ActionFactory<TTable, (_params: Record<string, unknown>) => Promise<unknown | undefined>>;
+    getTableName(table: TTable): string;
+}): ({ db, getSession }: {
+    db?: unknown;
+    getSession: SessionGetter;
+}) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Q extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>({ schemas, access, table, openApiOperation, relations, setParams, jsonArrayFields, handler, catch: catchHandler, }: GetOperationOptions<T, Q, TTable, TRelations>) => import("next-rest-framework").RouteOperationDefinition<"GET">;
+export interface GetListOperationOptions<T extends ZodSchema, Q extends ZodSchema, TTable, TRelations> extends Omit<GetOperationOptions<T, Q, TTable, TRelations>, "handler"> {
+    handler?: <D extends T>(_payload: {
+        params: GetOperationParams<Q>;
+        data: {
+            data: z.infer<D>[];
+            total: number;
+        };
+        req: NextRequest;
+    }) => Promise<{
+        data: z.infer<T>[];
+        total: number;
+    }>;
+}
+export declare function createGetListOperationFactory<TTable, TRelations>({ createAction, getTableName, }: {
+    createAction: ActionFactory<TTable, (_params: Record<string, unknown>) => Promise<{
+        data: unknown[];
+        total: number;
+    }>>;
+    getTableName(table: TTable): string;
+}): ({ db, getSession }: {
+    db?: unknown;
+    getSession: SessionGetter;
+}) => <T extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Q extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>({ schemas, access, table, openApiOperation, relations, jsonArrayFields, setParams, handler, catch: catchHandler, }: GetListOperationOptions<T, Q, TTable, TRelations>) => import("next-rest-framework").RouteOperationDefinition<"GET">;

package/lib/backend/route-operation/read-operation-core.js

@@ -0,0 +1,151 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/route-operation/read-operation-core.ts
+var read_operation_core_exports = {};
+__export(read_operation_core_exports, {
+  createGetListOperationFactory: () => createGetListOperationFactory,
+  createGetOperationFactory: () => createGetOperationFactory
+});
+module.exports = __toCommonJS(read_operation_core_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_schemas = require("../schemas");
+var import_open_api_operation = require("./open-api-operation");
+var import_operation_common = require("./operation-common");
+function createGetOperationFactory({
+  createAction,
+  getTableName
+}) {
+  return ({ db, getSession }) => ({
+    schemas,
+    access,
+    table,
+    openApiOperation,
+    relations,
+    setParams,
+    jsonArrayFields,
+    handler,
+    catch: catchHandler
+  }) => (0, import_next_rest_framework.routeOperation)({
+    method: "GET",
+    openApiOperation: (0, import_open_api_operation.createOpenApiOperation)({
+      defaultTags: (0, import_operation_common.getDefaultTags)({ getTableName, table }),
+      openApiOperation
+    })
+  }).input({
+    query: schemas.query
+  }).outputs([
+    {
+      body: schemas.response,
+      contentType: "application/json",
+      status: 200
+    }
+  ]).handler(async (req) => {
+    try {
+      const mergedParams = await (0, import_operation_common.getReadParams)({
+        access,
+        getSession,
+        req,
+        schemas,
+        setParams
+      });
+      const rawResult = table && db ? await createAction({
+        bodySchema: schemas.response,
+        db,
+        jsonArrayFields,
+        relations,
+        table
+      })(mergedParams) : mergedParams;
+      let result = rawResult ?? {};
+      if (handler) {
+        result = await handler({
+          data: result,
+          params: mergedParams,
+          req
+        });
+      }
+      return import_next_rest_framework.TypedNextResponse.json(result, { status: 200 });
+    } catch (error) {
+      return (0, import_operation_common.handleOperationError)(error, catchHandler);
+    }
+  });
+}
+function createGetListOperationFactory({
+  createAction,
+  getTableName
+}) {
+  return ({ db, getSession }) => ({
+    schemas,
+    access,
+    table,
+    openApiOperation,
+    relations,
+    jsonArrayFields,
+    setParams,
+    handler,
+    catch: catchHandler
+  }) => (0, import_next_rest_framework.routeOperation)({
+    method: "GET",
+    openApiOperation: (0, import_open_api_operation.createOpenApiOperation)({
+      defaultTags: (0, import_operation_common.getDefaultTags)({ getTableName, table }),
+      openApiOperation
+    })
+  }).input({
+    query: schemas.query
+  }).outputs([
+    {
+      body: (0, import_schemas.listBodySchema)(schemas.response),
+      contentType: "application/json",
+      status: 200
+    }
+  ]).handler(async (req) => {
+    try {
+      const mergedParams = await (0, import_operation_common.getReadParams)({
+        access,
+        getSession,
+        req,
+        schemas,
+        setParams
+      });
+      let result = table && db ? await createAction({
+        bodySchema: schemas.response,
+        db,
+        jsonArrayFields,
+        relations,
+        table
+      })(mergedParams) : { data: [], total: 0 };
+      if (handler) {
+        result = await handler({
+          data: result,
+          params: mergedParams,
+          req
+        });
+      }
+      return import_next_rest_framework.TypedNextResponse.json(result, {
+        status: 200
+      });
+    } catch (error) {
+      return (0, import_operation_common.handleOperationError)(error, catchHandler);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGetListOperationFactory,
+  createGetOperationFactory
+});

package/lib/backend/route-operation/write-operation-core.d.ts

@@ -0,0 +1,94 @@
+import { NextRequest } from "next/server";
+import { TypedNextRequest } from "next-rest-framework";
+import { z, ZodSchema } from "zod";
+import { type RouteOpenApiOperation } from "./open-api-operation.js";
+import { ActionFactory, RouteCatch, SessionGetter } from "./operation-common.js";
+export type PostOperationParams<IB extends ZodSchema> = z.infer<IB> & Record<string, unknown> & {
+    creatorId?: string;
+};
+export interface PostOperationOptions<IB extends ZodSchema, OB extends ZodSchema, TTable> {
+    schemas: {
+        body: IB;
+        response?: OB;
+    };
+    contentType?: string;
+    openApiOperation?: RouteOpenApiOperation;
+    parseBody?: (_req: NextRequest) => Promise<Record<string, unknown>>;
+    setBody?: (_req: NextRequest) => Promise<Partial<z.infer<IB>>>;
+    handler?: (_payload: {
+        params: PostOperationParams<IB>;
+        data: z.infer<OB>;
+        req: NextRequest;
+    }) => Promise<z.infer<OB>>;
+    catch?: RouteCatch;
+    table?: TTable;
+}
+export declare function createPostOperationFactory<TTable>({ createAction, getTableName, }: {
+    createAction: ActionFactory<TTable, (_body: Record<string, unknown>) => Promise<unknown[]>>;
+    getTableName(table: TTable): string;
+}): ({ db, getSession }: {
+    db?: unknown;
+    getSession: SessionGetter;
+}) => <IB extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, OB extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>({ schemas, contentType, openApiOperation, parseBody, setBody, table, handler, catch: catchHandler, }: PostOperationOptions<IB, OB, TTable>) => import("next-rest-framework").RouteOperationDefinition<"POST">;
+export type PutOperationParams<IB extends ZodSchema> = z.infer<IB> & Record<string, unknown> & {
+    editorId?: string;
+};
+export interface PutOperationOptions<IB extends ZodSchema, OB extends ZodSchema, TTable> {
+    schemas: {
+        body: IB;
+        response?: OB;
+    };
+    access?: {
+        byCreator?: boolean;
+    };
+    openApiOperation?: RouteOpenApiOperation;
+    table?: TTable;
+    setBody?: (_req: TypedNextRequest<"PUT", "application/json", z.infer<IB>>) => Promise<Partial<z.infer<IB>>>;
+    handler?: (_payload: {
+        params: PutOperationParams<IB>;
+        data: z.infer<OB>;
+        req: NextRequest;
+    }) => Promise<z.infer<OB>>;
+    catch?: RouteCatch;
+}
+export declare function createPutOperationFactory<TTable>({ createAction, getTableName, }: {
+    createAction: ActionFactory<TTable, (_body: Record<string, unknown>, _options?: {
+        byCreator?: boolean;
+    }) => Promise<unknown>>;
+    getTableName(table: TTable): string;
+}): ({ db, getSession }: {
+    db?: unknown;
+    getSession: SessionGetter;
+}) => <IB extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, OB extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>({ schemas, access, openApiOperation, table, setBody, handler, catch: catchHandler, }: PutOperationOptions<IB, OB, TTable>) => import("next-rest-framework").RouteOperationDefinition<"PUT">;
+export type DeleteOperationParams<B extends ZodSchema> = z.infer<B> & Record<string, unknown> & {
+    creatorId?: string;
+    id: string;
+};
+export interface DeleteOperationOptions<TTable, B extends ZodSchema> {
+    table?: TTable;
+    schemas?: {
+        body?: B;
+    };
+    access?: {
+        byCreator?: boolean;
+    };
+    openApiOperation?: RouteOpenApiOperation;
+    handler?: (_payload: {
+        params: DeleteOperationParams<B>;
+        data: unknown;
+        req: NextRequest;
+    }) => Promise<void>;
+    catch?: RouteCatch;
+}
+export declare function createDeleteOperationFactory<TTable>({ createAction, getTableName, }: {
+    createAction: ActionFactory<TTable, (_params: {
+        id: string;
+        creatorId?: string;
+    }) => Promise<unknown>>;
+    getTableName(table: TTable): string;
+}): ({ db, getSession }: {
+    db?: unknown;
+    getSession: SessionGetter;
+}) => <B extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> = z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>>({ table, schemas, access, openApiOperation, handler, catch: catchHandler, }: DeleteOperationOptions<TTable, B>) => import("next-rest-framework").RouteOperationDefinition<"DELETE">;