@visulima/crud 3.0.0-alpha.8 → 3.0.0-alpha.9

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## @visulima/crud [3.0.0-alpha.9](https://github.com/visulima/visulima/compare/@visulima/crud@3.0.0-alpha.8...@visulima/crud@3.0.0-alpha.9) (2026-04-08)
+
+### Bug Fixes
+
+* **crud:** fix packem build by adding externals, types, and missing deps ([391443f](https://github.com/visulima/visulima/commit/391443fb8d215760c0244d4a5a7e404026d520a6))
+
+### Miscellaneous Chores
+
+* **api:** remove empty dependency objects from package.json ([f6bfc85](https://github.com/visulima/visulima/commit/f6bfc85c48c973ff8ea0a7db5951794ae0ea3efb))
+* **crud:** add tsconfig.eslint.json for type-aware linting ([1d92809](https://github.com/visulima/visulima/commit/1d92809571908a03b70d2a8aa18be1b8cbb6db8d))
+* **crud:** apply prettier formatting ([9499add](https://github.com/visulima/visulima/commit/9499add951d9d55ba4c438f0b9360928e676c995))
+* **crud:** migrate .prettierrc.cjs to prettier.config.js ([17e09d4](https://github.com/visulima/visulima/commit/17e09d43561fafcdb8009ae334febaf62811659f))
+* **crud:** sort package.json fields ([6009768](https://github.com/visulima/visulima/commit/600976801578afcd170fcc889bcf534a8123b293))
+* update bundled dependency licenses ([6ace4c6](https://github.com/visulima/visulima/commit/6ace4c69d41fc1fd0a744fbca8ca219ba631b4ab))
+
+### Build System
+
+* **api-platform, crud:** migrate from tsup to packem ([e8aadac](https://github.com/visulima/visulima/commit/e8aadac072738c7c75e3a6a1478318922f2ceeac))
+
+
+### Dependencies
+
+* **@visulima/pagination:** upgraded to 5.0.0-alpha.9
+* **@visulima/prisma-dmmf-transformer:** upgraded to 3.0.0-alpha.8
+
 ## @visulima/crud [3.0.0-alpha.8](https://github.com/visulima/visulima/compare/@visulima/crud@3.0.0-alpha.7...@visulima/crud@3.0.0-alpha.8) (2026-03-26)
 
 ### Features

package/LICENSE.md

@@ -21,6 +21,27 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 <!-- DEPENDENCIES -->
+
+# Licenses of bundled dependencies
+The published @visulima/crud artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled dependencies:
+## dot-prop
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/dot-prop
+
+> MIT License
+>
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 <!-- /DEPENDENCIES -->
 
 <!-- TYPE_DEPENDENCIES -->

package/dist/adapter/prisma/index.d.cts

@@ -0,0 +1,39 @@
+import type { HttpError } from "http-errors";
+import type { Adapter, FakePrismaClient, PaginationData, ParsedQueryParameters } from "../../types.d.cts";
+import type { PrismaParsedQueryParameters } from "./types.d.cts";
+interface AdapterCtorArguments<M extends string, PrismaClient> {
+    manyRelations?: {
+        [key in M]?: string[];
+    };
+    models?: M[];
+    primaryKey?: string;
+    prismaClient: PrismaClient;
+}
+export default class PrismaAdapter<T, M extends string, PrismaClient> implements Adapter<T, PrismaParsedQueryParameters, M> {
+    models?: M[];
+    private readonly ctorModels?;
+    private dmmf;
+    private readonly manyRelations;
+    private readonly primaryKey;
+    private readonly prismaClient;
+    constructor({ manyRelations, models, primaryKey, prismaClient }: AdapterCtorArguments<M, FakePrismaClient & PrismaClient>);
+    connect(): Promise<void>;
+    create(resourceName: M, data: unknown, query: PrismaParsedQueryParameters): Promise<T>;
+    delete(resourceName: M, resourceId: number | string, query: PrismaParsedQueryParameters): Promise<T>;
+    disconnect(): Promise<void>;
+    getAll(resourceName: M, query: PrismaParsedQueryParameters): Promise<T[]>;
+    getModels(): M[];
+    getOne(resourceName: M, resourceId: number | string, query: PrismaParsedQueryParameters): Promise<T>;
+    getPaginationData(resourceName: M, query: PrismaParsedQueryParameters): Promise<PaginationData>;
+    handleError(error: Error): HttpError;
+    init(): Promise<void>;
+    mapModelsToRouteNames(): Promise<{
+        [key in M]?: string;
+    }>;
+    parseQuery(resourceName: M, query: ParsedQueryParameters): PrismaParsedQueryParameters;
+    update(resourceName: M, resourceId: number | string, data: unknown, query: PrismaParsedQueryParameters): Promise<T>;
+    get client(): PrismaClient;
+    private readonly getPrismaClientModels;
+    private getPrismaDelegate;
+}
+export {};

package/dist/adapter/prisma/index.d.mts

@@ -0,0 +1,39 @@
+import type { HttpError } from "http-errors";
+import type { Adapter, FakePrismaClient, PaginationData, ParsedQueryParameters } from "../../types.d.mts";
+import type { PrismaParsedQueryParameters } from "./types.d.mts";
+interface AdapterCtorArguments<M extends string, PrismaClient> {
+    manyRelations?: {
+        [key in M]?: string[];
+    };
+    models?: M[];
+    primaryKey?: string;
+    prismaClient: PrismaClient;
+}
+export default class PrismaAdapter<T, M extends string, PrismaClient> implements Adapter<T, PrismaParsedQueryParameters, M> {
+    models?: M[];
+    private readonly ctorModels?;
+    private dmmf;
+    private readonly manyRelations;
+    private readonly primaryKey;
+    private readonly prismaClient;
+    constructor({ manyRelations, models, primaryKey, prismaClient }: AdapterCtorArguments<M, FakePrismaClient & PrismaClient>);
+    connect(): Promise<void>;
+    create(resourceName: M, data: unknown, query: PrismaParsedQueryParameters): Promise<T>;
+    delete(resourceName: M, resourceId: number | string, query: PrismaParsedQueryParameters): Promise<T>;
+    disconnect(): Promise<void>;
+    getAll(resourceName: M, query: PrismaParsedQueryParameters): Promise<T[]>;
+    getModels(): M[];
+    getOne(resourceName: M, resourceId: number | string, query: PrismaParsedQueryParameters): Promise<T>;
+    getPaginationData(resourceName: M, query: PrismaParsedQueryParameters): Promise<PaginationData>;
+    handleError(error: Error): HttpError;
+    init(): Promise<void>;
+    mapModelsToRouteNames(): Promise<{
+        [key in M]?: string;
+    }>;
+    parseQuery(resourceName: M, query: ParsedQueryParameters): PrismaParsedQueryParameters;
+    update(resourceName: M, resourceId: number | string, data: unknown, query: PrismaParsedQueryParameters): Promise<T>;
+    get client(): PrismaClient;
+    private readonly getPrismaClientModels;
+    private getPrismaDelegate;
+}
+export {};

package/dist/adapter/prisma/index.d.ts

@@ -0,0 +1,39 @@
+import type { HttpError } from "http-errors";
+import type { Adapter, FakePrismaClient, PaginationData, ParsedQueryParameters } from "../../types.d.ts";
+import type { PrismaParsedQueryParameters } from "./types.d.ts";
+interface AdapterCtorArguments<M extends string, PrismaClient> {
+    manyRelations?: {
+        [key in M]?: string[];
+    };
+    models?: M[];
+    primaryKey?: string;
+    prismaClient: PrismaClient;
+}
+export default class PrismaAdapter<T, M extends string, PrismaClient> implements Adapter<T, PrismaParsedQueryParameters, M> {
+    models?: M[];
+    private readonly ctorModels?;
+    private dmmf;
+    private readonly manyRelations;
+    private readonly primaryKey;
+    private readonly prismaClient;
+    constructor({ manyRelations, models, primaryKey, prismaClient }: AdapterCtorArguments<M, FakePrismaClient & PrismaClient>);
+    connect(): Promise<void>;
+    create(resourceName: M, data: unknown, query: PrismaParsedQueryParameters): Promise<T>;
+    delete(resourceName: M, resourceId: number | string, query: PrismaParsedQueryParameters): Promise<T>;
+    disconnect(): Promise<void>;
+    getAll(resourceName: M, query: PrismaParsedQueryParameters): Promise<T[]>;
+    getModels(): M[];
+    getOne(resourceName: M, resourceId: number | string, query: PrismaParsedQueryParameters): Promise<T>;
+    getPaginationData(resourceName: M, query: PrismaParsedQueryParameters): Promise<PaginationData>;
+    handleError(error: Error): HttpError;
+    init(): Promise<void>;
+    mapModelsToRouteNames(): Promise<{
+        [key in M]?: string;
+    }>;
+    parseQuery(resourceName: M, query: ParsedQueryParameters): PrismaParsedQueryParameters;
+    update(resourceName: M, resourceId: number | string, data: unknown, query: PrismaParsedQueryParameters): Promise<T>;
+    get client(): PrismaClient;
+    private readonly getPrismaClientModels;
+    private getPrismaDelegate;
+}
+export {};

package/dist/adapter/prisma/types.d.cts

@@ -0,0 +1,31 @@
+import type { Condition, SearchCondition } from "../../types.d.cts";
+export type PrismaRecursiveField = "include" | "select";
+export type PrismaRecursive<T extends PrismaRecursiveField> = Record<string, boolean | {
+    [key in T]: PrismaRecursive<T>;
+}>;
+export type PrismaWhereOperator = "contains" | "endsWith" | "equals" | "gt" | "gte" | "in" | "lt" | "lte" | "not" | "notIn" | "startsWith";
+export type PrismaOrderByOperator = "asc" | "desc";
+export type PrismaFieldFilterOperator = {
+    [key in PrismaWhereOperator]?: SearchCondition;
+};
+export type PrismaFieldFilter = Record<string, Condition | PrismaFieldFilterOperator | PrismaRelationFilter | SearchCondition | undefined>;
+export type PrismaWhereField = PrismaFieldFilter & {
+    AND?: PrismaFieldFilter;
+    NOT?: PrismaFieldFilter;
+    OR?: PrismaFieldFilter;
+};
+export interface PrismaRelationFilter {
+    some?: PrismaFieldFilter | SearchCondition;
+}
+export type PrismaOrderBy = Record<string, PrismaOrderByOperator>;
+export type PrismaCursor = Record<string, boolean | number | string>;
+export interface PrismaParsedQueryParameters {
+    cursor?: PrismaCursor;
+    distinct?: string;
+    include?: PrismaRecursive<"include">;
+    orderBy?: PrismaOrderBy;
+    select?: PrismaRecursive<"select">;
+    skip?: number;
+    take?: number;
+    where?: PrismaWhereField;
+}

package/dist/adapter/prisma/types.d.mts

@@ -0,0 +1,31 @@
+import type { Condition, SearchCondition } from "../../types.d.mts";
+export type PrismaRecursiveField = "include" | "select";
+export type PrismaRecursive<T extends PrismaRecursiveField> = Record<string, boolean | {
+    [key in T]: PrismaRecursive<T>;
+}>;
+export type PrismaWhereOperator = "contains" | "endsWith" | "equals" | "gt" | "gte" | "in" | "lt" | "lte" | "not" | "notIn" | "startsWith";
+export type PrismaOrderByOperator = "asc" | "desc";
+export type PrismaFieldFilterOperator = {
+    [key in PrismaWhereOperator]?: SearchCondition;
+};
+export type PrismaFieldFilter = Record<string, Condition | PrismaFieldFilterOperator | PrismaRelationFilter | SearchCondition | undefined>;
+export type PrismaWhereField = PrismaFieldFilter & {
+    AND?: PrismaFieldFilter;
+    NOT?: PrismaFieldFilter;
+    OR?: PrismaFieldFilter;
+};
+export interface PrismaRelationFilter {
+    some?: PrismaFieldFilter | SearchCondition;
+}
+export type PrismaOrderBy = Record<string, PrismaOrderByOperator>;
+export type PrismaCursor = Record<string, boolean | number | string>;
+export interface PrismaParsedQueryParameters {
+    cursor?: PrismaCursor;
+    distinct?: string;
+    include?: PrismaRecursive<"include">;
+    orderBy?: PrismaOrderBy;
+    select?: PrismaRecursive<"select">;
+    skip?: number;
+    take?: number;
+    where?: PrismaWhereField;
+}

package/dist/adapter/prisma/types.d.ts

@@ -0,0 +1,31 @@
+import type { Condition, SearchCondition } from "../../types.d.ts";
+export type PrismaRecursiveField = "include" | "select";
+export type PrismaRecursive<T extends PrismaRecursiveField> = Record<string, boolean | {
+    [key in T]: PrismaRecursive<T>;
+}>;
+export type PrismaWhereOperator = "contains" | "endsWith" | "equals" | "gt" | "gte" | "in" | "lt" | "lte" | "not" | "notIn" | "startsWith";
+export type PrismaOrderByOperator = "asc" | "desc";
+export type PrismaFieldFilterOperator = {
+    [key in PrismaWhereOperator]?: SearchCondition;
+};
+export type PrismaFieldFilter = Record<string, Condition | PrismaFieldFilterOperator | PrismaRelationFilter | SearchCondition | undefined>;
+export type PrismaWhereField = PrismaFieldFilter & {
+    AND?: PrismaFieldFilter;
+    NOT?: PrismaFieldFilter;
+    OR?: PrismaFieldFilter;
+};
+export interface PrismaRelationFilter {
+    some?: PrismaFieldFilter | SearchCondition;
+}
+export type PrismaOrderBy = Record<string, PrismaOrderByOperator>;
+export type PrismaCursor = Record<string, boolean | number | string>;
+export interface PrismaParsedQueryParameters {
+    cursor?: PrismaCursor;
+    distinct?: string;
+    include?: PrismaRecursive<"include">;
+    orderBy?: PrismaOrderBy;
+    select?: PrismaRecursive<"select">;
+    skip?: number;
+    take?: number;
+    where?: PrismaWhereField;
+}

package/dist/adapter/prisma/utils/models-to-route-names.d.cts

@@ -0,0 +1,5 @@
+type RouteMap<M extends string> = {
+    [key in M]?: string;
+};
+declare const modelsToRouteNames: <M extends string = string>(mappingsMap: Record<string, object>, models: M[]) => RouteMap<M>;
+export = modelsToRouteNames;

package/dist/adapter/prisma/utils/models-to-route-names.d.mts

@@ -0,0 +1,5 @@
+type RouteMap<M extends string> = {
+    [key in M]?: string;
+};
+declare const modelsToRouteNames: <M extends string = string>(mappingsMap: Record<string, object>, models: M[]) => RouteMap<M>;
+export default modelsToRouteNames;

package/dist/adapter/prisma/utils/models-to-route-names.d.ts

@@ -0,0 +1,5 @@
+type RouteMap<M extends string> = {
+    [key in M]?: string;
+};
+declare const modelsToRouteNames: <M extends string = string>(mappingsMap: Record<string, object>, models: M[]) => RouteMap<M>;
+export = modelsToRouteNames;

package/dist/adapter/prisma/utils/parse-cursor.d.cts

@@ -0,0 +1,3 @@
+import type { PrismaCursor } from "../types.d.cts";
+declare const parsePrismaCursor: (cursor: Record<string, boolean | number | string>) => PrismaCursor;
+export = parsePrismaCursor;

package/dist/adapter/prisma/utils/parse-cursor.d.mts

@@ -0,0 +1,3 @@
+import type { PrismaCursor } from "../types.d.mts";
+declare const parsePrismaCursor: (cursor: Record<string, boolean | number | string>) => PrismaCursor;
+export default parsePrismaCursor;

package/dist/adapter/prisma/utils/parse-cursor.d.ts

@@ -0,0 +1,3 @@
+import type { PrismaCursor } from "../types.d.ts";
+declare const parsePrismaCursor: (cursor: Record<string, boolean | number | string>) => PrismaCursor;
+export = parsePrismaCursor;

package/dist/adapter/prisma/utils/parse-order-by.d.cts

@@ -0,0 +1,4 @@
+import type { OrderByField } from "../../../types.d.cts";
+import type { PrismaOrderBy } from "../types.d.cts";
+declare const parsePrismaOrderBy: (orderBy: OrderByField) => PrismaOrderBy;
+export = parsePrismaOrderBy;

package/dist/adapter/prisma/utils/parse-order-by.d.mts

@@ -0,0 +1,4 @@
+import type { OrderByField } from "../../../types.d.mts";
+import type { PrismaOrderBy } from "../types.d.mts";
+declare const parsePrismaOrderBy: (orderBy: OrderByField) => PrismaOrderBy;
+export default parsePrismaOrderBy;

package/dist/adapter/prisma/utils/parse-order-by.d.ts

@@ -0,0 +1,4 @@
+import type { OrderByField } from "../../../types.d.ts";
+import type { PrismaOrderBy } from "../types.d.ts";
+declare const parsePrismaOrderBy: (orderBy: OrderByField) => PrismaOrderBy;
+export = parsePrismaOrderBy;

package/dist/adapter/prisma/utils/parse-recursive.d.cts

@@ -0,0 +1,4 @@
+import type { RecursiveField } from "../../../types.d.cts";
+import type { PrismaRecursive, PrismaRecursiveField } from "../types.d.cts";
+declare const parsePrismaRecursiveField: <T extends PrismaRecursiveField>(select: RecursiveField, fieldName: T) => PrismaRecursive<T>;
+export = parsePrismaRecursiveField;

package/dist/adapter/prisma/utils/parse-recursive.d.mts

@@ -0,0 +1,4 @@
+import type { RecursiveField } from "../../../types.d.mts";
+import type { PrismaRecursive, PrismaRecursiveField } from "../types.d.mts";
+declare const parsePrismaRecursiveField: <T extends PrismaRecursiveField>(select: RecursiveField, fieldName: T) => PrismaRecursive<T>;
+export default parsePrismaRecursiveField;

package/dist/adapter/prisma/utils/parse-recursive.d.ts

@@ -0,0 +1,4 @@
+import type { RecursiveField } from "../../../types.d.ts";
+import type { PrismaRecursive, PrismaRecursiveField } from "../types.d.ts";
+declare const parsePrismaRecursiveField: <T extends PrismaRecursiveField>(select: RecursiveField, fieldName: T) => PrismaRecursive<T>;
+export = parsePrismaRecursiveField;

package/dist/adapter/prisma/utils/parse-where.d.cts

@@ -0,0 +1,4 @@
+import type { WhereField } from "../../../types.d.cts";
+import type { PrismaWhereField } from "../types.d.cts";
+declare const parsePrismaWhere: (where: WhereField, manyRelations: string[]) => PrismaWhereField;
+export = parsePrismaWhere;

package/dist/adapter/prisma/utils/parse-where.d.mts

@@ -0,0 +1,4 @@
+import type { WhereField } from "../../../types.d.mts";
+import type { PrismaWhereField } from "../types.d.mts";
+declare const parsePrismaWhere: (where: WhereField, manyRelations: string[]) => PrismaWhereField;
+export default parsePrismaWhere;

package/dist/adapter/prisma/utils/parse-where.d.ts

@@ -0,0 +1,4 @@
+import type { WhereField } from "../../../types.d.ts";
+import type { PrismaWhereField } from "../types.d.ts";
+declare const parsePrismaWhere: (where: WhereField, manyRelations: string[]) => PrismaWhereField;
+export = parsePrismaWhere;

package/dist/base-crud-handler.d.cts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Adapter, ExecuteHandler, HandlerOptions, ParsedQueryParameters } from "./types.d.cts";
+interface ResponseConfig {
+    data: any;
+    status: number;
+}
+declare function baseHandler<R extends Request, Context, T, Q extends ParsedQueryParameters = any, M extends string = string>(responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>, finalExecutor: (responseOrContext: Context) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Context>>;
+declare function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = any, M extends string = string>(responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>, finalExecutor: (responseOrContext: RResponse) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, RResponse>>;
+export = baseHandler;

package/dist/base-crud-handler.d.mts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Adapter, ExecuteHandler, HandlerOptions, ParsedQueryParameters } from "./types.d.mts";
+interface ResponseConfig {
+    data: any;
+    status: number;
+}
+declare function baseHandler<R extends Request, Context, T, Q extends ParsedQueryParameters = any, M extends string = string>(responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>, finalExecutor: (responseOrContext: Context) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Context>>;
+declare function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = any, M extends string = string>(responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>, finalExecutor: (responseOrContext: RResponse) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, RResponse>>;
+export default baseHandler;

package/dist/base-crud-handler.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Adapter, ExecuteHandler, HandlerOptions, ParsedQueryParameters } from "./types.d.ts";
+interface ResponseConfig {
+    data: any;
+    status: number;
+}
+declare function baseHandler<R extends Request, Context, T, Q extends ParsedQueryParameters = any, M extends string = string>(responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>, finalExecutor: (responseOrContext: Context) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Context>>;
+declare function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = any, M extends string = string>(responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>, finalExecutor: (responseOrContext: RResponse) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, RResponse>>;
+export = baseHandler;

package/dist/handler/create.d.cts

@@ -0,0 +1,11 @@
+import type { HandlerParameters } from "../types.d.cts";
+declare const createHandler: Handler;
+export type Handler = <T, Q, Request>(parameters: HandlerParameters<T, Q> & {
+    request: Request & {
+        body: Record<string, any>;
+    };
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = createHandler;

package/dist/handler/create.d.mts

@@ -0,0 +1,11 @@
+import type { HandlerParameters } from "../types.d.mts";
+declare const createHandler: Handler;
+export type Handler = <T, Q, Request>(parameters: HandlerParameters<T, Q> & {
+    request: Request & {
+        body: Record<string, any>;
+    };
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export default createHandler;

package/dist/handler/create.d.ts

@@ -0,0 +1,11 @@
+import type { HandlerParameters } from "../types.d.ts";
+declare const createHandler: Handler;
+export type Handler = <T, Q, Request>(parameters: HandlerParameters<T, Q> & {
+    request: Request & {
+        body: Record<string, any>;
+    };
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = createHandler;

package/dist/handler/delete.d.cts

@@ -0,0 +1,7 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.cts";
+declare const deleteHandler: Handler;
+export type Handler = <T, Q>(parameters: UniqueResourceHandlerParameters<T, Q>) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = deleteHandler;

package/dist/handler/delete.d.mts

@@ -0,0 +1,7 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.mts";
+declare const deleteHandler: Handler;
+export type Handler = <T, Q>(parameters: UniqueResourceHandlerParameters<T, Q>) => Promise<{
+    data: any;
+    status: number;
+}>;
+export default deleteHandler;

package/dist/handler/delete.d.ts

@@ -0,0 +1,7 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.ts";
+declare const deleteHandler: Handler;
+export type Handler = <T, Q>(parameters: UniqueResourceHandlerParameters<T, Q>) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = deleteHandler;

package/dist/handler/list.d.cts

@@ -0,0 +1,9 @@
+import type { HandlerParameters, PaginationConfig, ParsedQueryParameters } from "../types.d.cts";
+declare const listHandler: Handler;
+export type Handler = <T, Q extends ParsedQueryParameters>(parameters: HandlerParameters<T, Q> & {
+    pagination: PaginationConfig;
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = listHandler;

package/dist/handler/list.d.mts

@@ -0,0 +1,9 @@
+import type { HandlerParameters, PaginationConfig, ParsedQueryParameters } from "../types.d.mts";
+declare const listHandler: Handler;
+export type Handler = <T, Q extends ParsedQueryParameters>(parameters: HandlerParameters<T, Q> & {
+    pagination: PaginationConfig;
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export default listHandler;

package/dist/handler/list.d.ts

@@ -0,0 +1,9 @@
+import type { HandlerParameters, PaginationConfig, ParsedQueryParameters } from "../types.d.ts";
+declare const listHandler: Handler;
+export type Handler = <T, Q extends ParsedQueryParameters>(parameters: HandlerParameters<T, Q> & {
+    pagination: PaginationConfig;
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = listHandler;

package/dist/handler/read.d.cts

@@ -0,0 +1,7 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.cts";
+declare const readHandler: Handler;
+export type Handler = <T, Q>(parameters: UniqueResourceHandlerParameters<T, Q>) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = readHandler;

package/dist/handler/read.d.mts

@@ -0,0 +1,7 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.mts";
+declare const readHandler: Handler;
+export type Handler = <T, Q>(parameters: UniqueResourceHandlerParameters<T, Q>) => Promise<{
+    data: any;
+    status: number;
+}>;
+export default readHandler;

package/dist/handler/read.d.ts

@@ -0,0 +1,7 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.ts";
+declare const readHandler: Handler;
+export type Handler = <T, Q>(parameters: UniqueResourceHandlerParameters<T, Q>) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = readHandler;

package/dist/handler/update.d.cts

@@ -0,0 +1,11 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.cts";
+declare const updateHandler: Handler;
+export type Handler = <T, Q, Request>(parameters: UniqueResourceHandlerParameters<T, Q> & {
+    request: Request & {
+        body: Partial<T>;
+    };
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = updateHandler;

package/dist/handler/update.d.mts

@@ -0,0 +1,11 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.mts";
+declare const updateHandler: Handler;
+export type Handler = <T, Q, Request>(parameters: UniqueResourceHandlerParameters<T, Q> & {
+    request: Request & {
+        body: Partial<T>;
+    };
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export default updateHandler;

package/dist/handler/update.d.ts

@@ -0,0 +1,11 @@
+import type { UniqueResourceHandlerParameters } from "../types.d.ts";
+declare const updateHandler: Handler;
+export type Handler = <T, Q, Request>(parameters: UniqueResourceHandlerParameters<T, Q> & {
+    request: Request & {
+        body: Partial<T>;
+    };
+}) => Promise<{
+    data: any;
+    status: number;
+}>;
+export = updateHandler;

package/dist/index.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const PrismaAdapter = require('./packem_shared/PrismaAdapter-BTCwgMow.cjs');
+const modelsToOpenApi = require('./packem_shared/modelsToOpenApi-WQ8Ol6q7.cjs');
+const RouteType = require('./packem_shared/RouteType-Bk3uAK0x.cjs');
+
+
+
+exports.PrismaAdapter = PrismaAdapter;
+exports.modelsToOpenApi = modelsToOpenApi;
+exports.RouteType = RouteType.RouteType;

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+export { default as PrismaAdapter } from "./adapter/prisma/index.d.cts";
+export type { ModelsToOpenApiParameters } from "./swagger/adapter/prisma/index.d.cts";
+export { default as modelsToOpenApi } from "./swagger/adapter/prisma/index.d.cts";
+export type { SwaggerModelsConfig } from "./swagger/types.d.cts";
+export type { Adapter, Condition, HandlerOptions as CrudHandlerOptions, HandlerParameters, ModelOption, ModelsOptions, OrderByField, OrderByOperator, PaginationConfig, PaginationData, ParsedQueryParameters, RecursiveField, SearchCondition, UniqueResourceHandlerParameters, WhereCondition, WhereField, WhereOperator, } from "./types.d.cts";
+export { RouteType } from "./types.d.cts";