prisma-guard 1.2.1 → 1.3.1

package/dist/runtime/index.d.cts

@@ -0,0 +1,188 @@
+import * as zod from 'zod';
+import { z } from 'zod';
+import * as zod_v4_core from 'zod/v4/core';
+
+interface FieldMeta {
+    type: string;
+    isList: boolean;
+    isRequired: boolean;
+    isId: boolean;
+    isRelation: boolean;
+    hasDefault: boolean;
+    isUpdatedAt: boolean;
+    isEnum?: boolean;
+    isUnique?: boolean;
+}
+interface GuardLogger {
+    warn(message: string): void;
+}
+type DataFieldRefine = (base: z.ZodTypeAny) => z.ZodTypeAny;
+type InputOpts = {
+    mode?: 'create' | 'update';
+    partial?: boolean;
+    allowNull?: boolean;
+    refine?: Record<string, (field: z.ZodTypeAny) => z.ZodTypeAny>;
+} & ({
+    pick: string[];
+    omit?: never;
+} | {
+    omit: string[];
+    pick?: never;
+} | {
+    pick?: never;
+    omit?: never;
+});
+type ModelOpts = {
+    include?: Record<string, ModelOpts>;
+    _count?: true | Record<string, true>;
+    strict?: boolean;
+    maxDepth?: number;
+} & ({
+    pick: string[];
+    omit?: never;
+} | {
+    omit: string[];
+    pick?: never;
+} | {
+    pick?: never;
+    omit?: never;
+});
+type QueryMethod = 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'count' | 'aggregate' | 'groupBy';
+type MutationMethod = 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany';
+interface ShapeConfig {
+    where?: Record<string, unknown>;
+    include?: Record<string, true | NestedIncludeArgs>;
+    select?: Record<string, true | NestedSelectArgs>;
+    orderBy?: Record<string, true>;
+    cursor?: Record<string, true>;
+    take?: {
+        max: number;
+        default?: number;
+    };
+    skip?: true;
+    distinct?: string[];
+    _count?: true | Record<string, true>;
+    _avg?: Record<string, true>;
+    _sum?: Record<string, true>;
+    _min?: Record<string, true>;
+    _max?: Record<string, true>;
+    by?: string[];
+    having?: Record<string, true>;
+}
+interface NestedIncludeArgs {
+    where?: Record<string, unknown>;
+    include?: Record<string, true | NestedIncludeArgs>;
+    select?: Record<string, true | NestedSelectArgs>;
+    orderBy?: Record<string, true>;
+    cursor?: Record<string, true>;
+    take?: {
+        max: number;
+        default?: number;
+    };
+    skip?: true;
+}
+interface NestedSelectArgs {
+    select?: Record<string, true | NestedSelectArgs>;
+    where?: Record<string, unknown>;
+    orderBy?: Record<string, true>;
+    cursor?: Record<string, true>;
+    take?: {
+        max: number;
+        default?: number;
+    };
+    skip?: true;
+}
+type ShapeOrFn<TCtx = unknown> = ShapeConfig | ((ctx: TCtx) => ShapeConfig);
+interface ScopeEntry {
+    readonly fk: string;
+    readonly root: string;
+    readonly relationName: string;
+}
+type ScopeMap = Record<string, readonly ScopeEntry[]>;
+type TypeMap = Record<string, Record<string, FieldMeta>>;
+type EnumMap = Record<string, readonly string[]>;
+type ZodChains = Record<string, Record<string, (base: any) => z.ZodTypeAny>>;
+type ZodDefaults = Record<string, readonly string[]>;
+type UniqueConstraint = readonly string[];
+type UniqueMap = Record<string, readonly UniqueConstraint[]>;
+type MissingScopeContextMode = 'error' | 'warn' | 'ignore';
+type FindUniqueMode = 'verify' | 'reject';
+type OnScopeRelationWrite = 'error' | 'warn' | 'strip';
+interface GuardGeneratedConfig {
+    onMissingScopeContext: MissingScopeContextMode;
+    findUniqueMode?: FindUniqueMode;
+    onScopeRelationWrite?: OnScopeRelationWrite;
+    strictDecimal?: boolean;
+    enforceProjection?: boolean;
+}
+interface GuardConfig {
+    scopeMap: ScopeMap;
+    typeMap: TypeMap;
+    enumMap: EnumMap;
+    zodChains: ZodChains;
+    guardConfig: GuardGeneratedConfig;
+    uniqueMap?: UniqueMap;
+    zodDefaults?: ZodDefaults;
+    logger?: GuardLogger;
+    wrapZodErrors?: boolean;
+}
+interface QuerySchema<TCtx = unknown> {
+    parse(body: unknown, opts?: {
+        ctx?: TCtx;
+        caller?: string;
+    }): Record<string, unknown>;
+    schemas: Partial<Record<string, z.ZodObject<any>>>;
+}
+interface InputSchema {
+    parse(data: unknown): Record<string, unknown>;
+    schema: z.ZodObject<any>;
+}
+interface GuardShape extends ShapeConfig {
+    data?: Record<string, true | DataFieldRefine | unknown>;
+    create?: Record<string, true | DataFieldRefine | unknown>;
+    update?: Record<string, true | DataFieldRefine | unknown>;
+}
+type GuardShapeOrFn = GuardShape | ((ctx: any) => GuardShape);
+type GuardInput = GuardShapeOrFn | Record<string, GuardShapeOrFn>;
+type GuardableMethodName = QueryMethod | MutationMethod;
+type ExtractReturn<T, K extends string> = K extends keyof T ? T[K] extends (...args: any[]) => infer R ? R : never : never;
+type GuardedModel<TDelegate> = {
+    [K in GuardableMethodName as K extends keyof TDelegate ? K : never]: ExtractReturn<TDelegate, K> extends never ? never : (body: unknown) => ExtractReturn<TDelegate, K>;
+};
+
+declare function createGuard<TModels extends TypeMap = TypeMap, TRoots extends string = string, TModelExt = unknown>(config: GuardConfig & {
+    typeMap: TModels;
+}): {
+    input: (model: Extract<keyof TModels, string>, opts: InputOpts) => InputSchema;
+    model: (model: Extract<keyof TModels, string>, opts: ModelOpts) => zod.ZodObject<any, zod_v4_core.$strip>;
+    query: <TCtx = unknown>(model: Extract<keyof TModels, string>, method: QueryMethod, config_: ShapeOrFn<TCtx> | Record<string, ShapeOrFn<TCtx>>) => QuerySchema<TCtx>;
+    extension: <TCtx extends Record<string, unknown> = Record<string, unknown>>(contextFn: () => TCtx) => {
+        name: string;
+        model: TModelExt;
+        query: {
+            $allOperations({ model, operation, args, query }: any): any;
+        };
+    };
+};
+
+declare class PolicyError extends Error {
+    readonly status = 403;
+    readonly code = "POLICY_DENIED";
+    constructor(message?: string, options?: ErrorOptions);
+}
+declare class ShapeError extends Error {
+    readonly status = 400;
+    readonly code = "SHAPE_INVALID";
+    constructor(message: string, options?: ErrorOptions);
+}
+declare class CallerError extends Error {
+    readonly status = 400;
+    readonly code = "CALLER_UNKNOWN";
+    constructor(message: string, options?: ErrorOptions);
+}
+
+declare function force<T>(value: T): {
+    value: T;
+};
+
+export { CallerError, type EnumMap, type FieldMeta, type GuardConfig, type GuardGeneratedConfig, type GuardInput, type GuardLogger, type GuardShape, type GuardShapeOrFn, type GuardedModel, type InputOpts, type InputSchema, type MissingScopeContextMode, type ModelOpts, type MutationMethod, type NestedIncludeArgs, type NestedSelectArgs, PolicyError, type QueryMethod, type QuerySchema, type ScopeEntry, type ScopeMap, type ShapeConfig, ShapeError, type ShapeOrFn, type TypeMap, type UniqueConstraint, type UniqueMap, type ZodChains, type ZodDefaults, createGuard, force };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-guard",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Prisma generator + runtime for input validation, query shape enforcement, and row-level tenant isolation",
   "license": "MIT",
   "type": "module",
@@ -13,8 +13,14 @@
       "types": "./dist/generator/index.d.ts"
     },
     ".": {
-      "import": "./dist/runtime/index.js",
-      "types": "./dist/runtime/index.d.ts"
+      "import": {
+        "types": "./dist/runtime/index.d.ts",
+        "default": "./dist/runtime/index.js"
+      },
+      "require": {
+        "types": "./dist/runtime/index.d.cts",
+        "default": "./dist/runtime/index.cjs"
+      }
     }
   },
   "bin": {