prisma-generator-express 1.16.7 → 1.19.0

package/src/copy/createOutputValidatorMiddleware.ts

@@ -29,7 +29,7 @@ export function createOutputValidatorMiddleware({
     res.send = function (data) {
       const validationResult = schema.safeParse(data)
       if (!validationResult.success) {
-        const errors = validationResult.error.errors
+        const errors = validationResult.error.issues
         next({
           status: 400,
           message: 'Output validation failed',

package/src/copy/createValidatorMiddleware.ts

@@ -42,7 +42,7 @@ export function createValidatorMiddleware({
     }
 
     if (!validationResult.success) {
-      const errors = validationResult.error.errors
+      const errors = validationResult.error.issues
       return next({
         status: 400,
         message: 'Validation failed',

package/src/copy/misc.ts

@@ -17,9 +17,30 @@ export function safeJSONparse<T>(
   if (data === 'false') return false
   if (data === 'undefined') return undefined
   if (data === 'null') return null
-  return isJsonString(data) ? JSON.parse(data as string) : data
+  return isJsonString(data) ? JSON.parse(data as string) : data as any
 }
 
 export const isObject = (value: unknown): value is Record<string, unknown> => {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
+
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
+
+export function isSafeKey(key: string): boolean {
+  return !UNSAFE_KEYS.has(key)
+}
+
+export function sanitizeKeys<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map(sanitizeKeys) as T
+  }
+  if (isObject(value)) {
+    const result: Record<string, unknown> = {}
+    for (const key of Object.keys(value)) {
+      if (!isSafeKey(key)) continue
+      result[key] = sanitizeKeys((value as Record<string, unknown>)[key])
+    }
+    return result as T
+  }
+  return value
+}

package/src/copy/operationDefinitions.ts

@@ -0,0 +1,96 @@
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete'
+
+export interface OperationDef {
+  name: string
+  method: HttpMethod
+  pathSuffix: string
+  configKey: string
+}
+
+export const OPERATION_DEFS: OperationDef[] = [
+  { name: 'findMany', method: 'get', pathSuffix: '', configKey: 'findMany' },
+  {
+    name: 'findUnique',
+    method: 'get',
+    pathSuffix: '/unique',
+    configKey: 'findUnique',
+  },
+  {
+    name: 'findUniqueOrThrow',
+    method: 'get',
+    pathSuffix: '/unique/strict',
+    configKey: 'findUniqueOrThrow',
+  },
+  {
+    name: 'findFirst',
+    method: 'get',
+    pathSuffix: '/first',
+    configKey: 'findFirst',
+  },
+  {
+    name: 'findFirstOrThrow',
+    method: 'get',
+    pathSuffix: '/first/strict',
+    configKey: 'findFirstOrThrow',
+  },
+  {
+    name: 'findManyPaginated',
+    method: 'get',
+    pathSuffix: '/paginated',
+    configKey: 'findManyPaginated',
+  },
+  { name: 'create', method: 'post', pathSuffix: '', configKey: 'create' },
+  {
+    name: 'createMany',
+    method: 'post',
+    pathSuffix: '/many',
+    configKey: 'createMany',
+  },
+  {
+    name: 'createManyAndReturn',
+    method: 'post',
+    pathSuffix: '/many/return',
+    configKey: 'createManyAndReturn',
+  },
+  { name: 'update', method: 'put', pathSuffix: '', configKey: 'update' },
+  {
+    name: 'updateMany',
+    method: 'put',
+    pathSuffix: '/many',
+    configKey: 'updateMany',
+  },
+  {
+    name: 'updateManyAndReturn',
+    method: 'put',
+    pathSuffix: '/many/return',
+    configKey: 'updateManyAndReturn',
+  },
+  { name: 'upsert', method: 'patch', pathSuffix: '', configKey: 'upsert' },
+  { name: 'delete', method: 'delete', pathSuffix: '', configKey: 'delete' },
+  {
+    name: 'deleteMany',
+    method: 'delete',
+    pathSuffix: '/many',
+    configKey: 'deleteMany',
+  },
+  { name: 'count', method: 'get', pathSuffix: '/count', configKey: 'count' },
+  {
+    name: 'aggregate',
+    method: 'get',
+    pathSuffix: '/aggregate',
+    configKey: 'aggregate',
+  },
+  {
+    name: 'groupBy',
+    method: 'get',
+    pathSuffix: '/groupby',
+    configKey: 'groupBy',
+  },
+]
+
+export function isOperationEnabled(
+  config: Record<string, any>,
+  def: OperationDef,
+): boolean {
+  return !!(config.enableAll || config[def.configKey])
+}

package/src/copy/parseQueryParams.ts

@@ -1,29 +1,38 @@
-import { isObject } from './misc'
-import { ParsedQs } from 'qs'
+import { isObject, isSafeKey, sanitizeKeys } from './misc'
 
-/**
- * Type definition for possible query parameter types.
- */
-type QueryParams = string | ParsedQs | string[] | ParsedQs[] | undefined
+type QueryParams =
+  | string
+  | Record<string, unknown>
+  | string[]
+  | Record<string, unknown>[]
+  | undefined
 
-/**
- * Parses a query value to convert strings to their respective types.
- * @param {string} value - The query value to parse.
- * @returns {unknown} The parsed value.
- */
-const parseQueryValue = (value: string): unknown => {
+const NUMERIC_KEYS = new Set(['take', 'skip'])
+
+const parseQueryValue = (value: string, key?: string): unknown => {
+  if (value.startsWith('{') || value.startsWith('[') || value.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(value)
+      return sanitizeKeys(parsed)
+    } catch {
+      // fall through
+    }
+  }
   if (value === 'true') return true
   if (value === 'false') return false
   if (value === 'null') return null
-  if (!isNaN(Number(value))) return Number(value)
+  if (
+    key &&
+    NUMERIC_KEYS.has(key) &&
+    value !== '' &&
+    !isNaN(Number(value)) &&
+    isFinite(Number(value))
+  ) {
+    return Number(value)
+  }
   return value
 }
 
-/**
- * Recursively parses query parameters to convert strings to their respective types.
- * @param {QueryParams} params - The query parameters to parse.
- * @returns {unknown} The parsed query parameters.
- */
 export const parseQueryParams = (params: QueryParams): unknown => {
   if (typeof params === 'string') {
     return parseQueryValue(params)
@@ -33,10 +42,16 @@ export const parseQueryParams = (params: QueryParams): unknown => {
   }
   if (isObject(params)) {
     const parsedParams: Record<string, unknown> = {}
-    for (const key in params) {
-      parsedParams[key] = parseQueryParams(params[key])
+    for (const key of Object.keys(params)) {
+      if (!isSafeKey(key)) continue
+      const raw = params[key]
+      if (typeof raw === 'string') {
+        parsedParams[key] = parseQueryValue(raw, key)
+      } else {
+        parsedParams[key] = raw
+      }
     }
     return parsedParams
   }
   return params
-}
+}

package/src/copy/routeConfig.ts

@@ -1,34 +1,76 @@
-import { RequestHandler } from 'express'
-import { ZodTypeAny } from 'zod'
+import { RequestHandler, Request } from 'express'
 
-export interface ValidatorConfig {
-  allow?: string[]
-  forbid?: string[]
-  schema: ZodTypeAny
+export interface OperationConfig {
+  before?: RequestHandler[]
+  after?: RequestHandler[]
+  shape?: Record<string, any>
 }
 
-interface MiddlewareConfig<M> {
-  before?: M[]
-  after?: RequestHandler[]
-  inputValidator?: ValidatorConfig
-  outputValidator?: ValidatorConfig
+export interface QueryBuilderConfig {
+  enabled?: boolean
+  port?: number
+  host?: string
+  schemaPath?: string
+  databaseUrl?: string
 }
 
-export interface RouteConfig<M> {
-  findFirst?: MiddlewareConfig<M>
-  findMany?: MiddlewareConfig<M>
-  findUnique?: MiddlewareConfig<M>
-  create?: MiddlewareConfig<M>
-  createMany?: MiddlewareConfig<M>
-  update?: MiddlewareConfig<M>
-  updateMany?: MiddlewareConfig<M>
-  upsert?: MiddlewareConfig<M>
-  delete?: MiddlewareConfig<M>
-  deleteMany?: MiddlewareConfig<M>
-  aggregate?: MiddlewareConfig<M>
-  count?: MiddlewareConfig<M>
-  groupBy?: MiddlewareConfig<M>
-  addModelPrefix?: boolean
+export interface OpenApiServerConfig {
+  url: string
+  description?: string
+}
+
+export interface OpenApiSecuritySchemeConfig {
+  type: string
+  scheme?: string
+  bearerFormat?: string
+  name?: string
+  in?: string
+  description?: string
+}
+
+export interface RouteConfig {
   enableAll?: boolean
+  addModelPrefix?: boolean
   customUrlPrefix?: string
-}
+  specBasePath?: string
+  disableOpenApi?: boolean
+  scalarCdnUrl?: string
+
+  openApiTitle?: string
+  openApiDescription?: string
+  openApiVersion?: string
+  openApiServers?: OpenApiServerConfig[]
+  openApiSecuritySchemes?: Record<string, OpenApiSecuritySchemeConfig>
+  openApiSecurity?: Record<string, string[]>[]
+
+  guard?: {
+    resolveVariant?: (req: Request) => string | undefined
+    variantHeader?: string
+  }
+
+  queryBuilder?: QueryBuilderConfig | false
+
+  pagination?: {
+    defaultLimit?: number
+    maxLimit?: number
+  }
+
+  findUnique?: OperationConfig
+  findUniqueOrThrow?: OperationConfig
+  findFirst?: OperationConfig
+  findFirstOrThrow?: OperationConfig
+  findMany?: OperationConfig
+  findManyPaginated?: OperationConfig
+  create?: OperationConfig
+  createMany?: OperationConfig
+  createManyAndReturn?: OperationConfig
+  update?: OperationConfig
+  updateMany?: OperationConfig
+  updateManyAndReturn?: OperationConfig
+  upsert?: OperationConfig
+  delete?: OperationConfig
+  deleteMany?: OperationConfig
+  aggregate?: OperationConfig
+  count?: OperationConfig
+  groupBy?: OperationConfig
+}

package/src/copy/transformZod.ts

@@ -1,12 +1,10 @@
 import { get } from 'lodash'
 import {
+  output,
   z,
-  ZodEffects,
   ZodError,
-  ZodIssue,
-  ZodIssueCode,
   ZodObject,
-  ZodTypeAny,
+  ZodType,
 } from 'zod'
 
 function startsWith(str: string, prefix: string): boolean {
@@ -34,13 +32,14 @@ function isKeyAllowed(key: string, allowedPaths: string[]): boolean {
   )
 }
 
-export function allow<T extends ZodTypeAny>(
+export function allow<T extends ZodType>(
   schema: T,
   allowedPaths: string[],
-): ZodEffects<T, any, any> {
-  const rootSchema = schema instanceof z.ZodObject ? schema.strict() : undefined
+) {
+  const schemaToTransform = schema instanceof z.ZodObject ? schema.strict() : schema
+  const rootSchema = schemaToTransform instanceof z.ZodObject ? schemaToTransform : undefined
 
-  return rootSchema?.transform((data) => {
+  return schemaToTransform.transform((data) => {
     const flatData = flattenObject(data, '', rootSchema)
 
     const disallowedPaths: string[] = []
@@ -56,13 +55,13 @@ export function allow<T extends ZodTypeAny>(
     }
 
     return data
-  }) as unknown as ZodEffects<T, any, any>
+  })
 }
 
-export function forbid<T extends z.ZodTypeAny>(
+export function forbid<T extends ZodType>(
   schema: T,
   forbiddenPaths: string[],
-): ZodEffects<T, any, any> {
+) {
   return schema.transform((data) => {
     const forbiddenMatches: string[] = []
 
@@ -78,11 +77,11 @@ export function forbid<T extends z.ZodTypeAny>(
       throw createZodErrorFromPaths(forbiddenMatches, 'Field is forbidden:')
     }
     return data
-  }) as ZodEffects<T, any, any>
+  })
 }
 
-export function flattenObject(
-  obj: Record<string, any>,
+export function flattenObject<T>(
+  obj: Record<string, any> | output<T>,
   prefix = '',
   schema?: ZodObject<any>,
 ): Record<string, any> {
@@ -128,10 +127,10 @@ function createZodErrorFromPaths(
   disallowedPaths: string[],
   errorMessage: string,
 ): ZodError {
-  const errors: ZodIssue[] = []
+  const errors: z.core.$ZodIssue[] = []
   for (const path of disallowedPaths) {
     errors.push({
-      code: ZodIssueCode.custom,
+      code: 'custom',
       message: `${errorMessage} '${path}'`,
       path: path.split('.'),
     })

package/dist/generator.js

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const generator_helper_1 = require("@prisma/generator-helper");
-const sdk_1 = require("@prisma/sdk");
-const constants_1 = require("./constants");
-const writeFileSafely_1 = require("./utils/writeFileSafely");
-const generateFindUnique_1 = require("./helpers/generateFindUnique");
-const generateImportPrismaStatement_1 = require("./helpers/generateImportPrismaStatement");
-const generateFindMany_1 = require("./helpers/generateFindMany");
-const generateFindFirst_1 = require("./helpers/generateFindFirst");
-const generateCreate_1 = require("./helpers/generateCreate");
-const generateRouteFile_1 = require("./helpers/generateRouteFile");
-const generateCreateMany_1 = require("./helpers/generateCreateMany");
-const generateUpdate_1 = require("./helpers/generateUpdate");
-const generateUpdateMany_1 = require("./helpers/generateUpdateMany");
-const generateUpsert_1 = require("./helpers/generateUpsert");
-const generateDelete_1 = require("./helpers/generateDelete");
-const generateDeleteMany_1 = require("./helpers/generateDeleteMany");
-const generateAggregate_1 = require("./helpers/generateAggregate");
-const generateCount_1 = require("./helpers/generateCount");
-const generateGroupBy_1 = require("./helpers/generateGroupBy");
-const copyFiles_1 = require("./utils/copyFiles");
-const { version } = require('../package.json');
-(0, generator_helper_1.generatorHandler)({
-    onManifest() {
-        sdk_1.logger.info(`${constants_1.GENERATOR_NAME}:Registered`);
-        return {
-            version,
-            defaultOutput: '../generated',
-            prettyName: constants_1.GENERATOR_NAME,
-        };
-    },
-    onGenerate: async (options) => {
-        const prismaImportStatement = (0, generateImportPrismaStatement_1.generateImportPrismaStatement)(options);
-        for await (const model of options.dmmf.datamodel.models) {
-            if (model.documentation &&
-                model.documentation.includes('generator off')) {
-                sdk_1.logger.info(`Skipping generation for model ${model.name} as it is marked with 'generator off'.`);
-                continue;
-            }
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateFindUnique_1.generateFindUniqueFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'FindUnique',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateFindFirst_1.generateFindFirstFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'FindFirst',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateFindMany_1.generateFindManyFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'FindMany',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateCreate_1.generateCreateFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'Create',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateCreateMany_1.generateCreateManyFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'CreateMany',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateUpdate_1.generateUpdateFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'Update',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateUpdateMany_1.generateUpdateManyFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'UpdateMany',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateUpsert_1.generateUpsertFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'Upsert',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateDelete_1.generateDeleteFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'Delete',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateDeleteMany_1.generateDeleteManyFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'DeleteMany',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateAggregate_1.generateAggregateFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'Aggregate',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateCount_1.generateCountFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'Count',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateGroupBy_1.generateGroupByFunction)({
-                    model,
-                    prismaImportStatement,
-                }),
-                options,
-                model,
-                operation: 'GroupBy',
-            });
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateRouteFile_1.generateRouterFunction)({ model }),
-                options,
-                model,
-                operation: 'index',
-            });
-        }
-        await (0, copyFiles_1.copyFiles)(options);
-    },
-});
-//# sourceMappingURL=generator.js.map

package/dist/generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generator.js","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"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"}

package/dist/helpers/generateAggregate.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAggregateFunction = void 0;
-const strings_1 = require("../utils/strings");
-const generateAggregateFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}Aggregate`;
-    const argsTypeName = `Prisma.${(0, strings_1.capitalize)(modelName)}AggregateArgs`;
-    return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
-import { ParsedQs } from 'qs'
-import { ZodTypeAny } from 'zod';
-import { ValidatorConfig } from '../routeConfig'
-
-interface AggregateRequest extends Request {
-  prisma: PrismaClient;
-  query: Partial<${argsTypeName}> & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  locals?: {
-    outputValidator?: ValidatorConfig;
-  };
-}
-
-export type AggregateMiddleware = RequestHandler<ParamsDictionary, any, Partial<${argsTypeName}>, Record<string, any>>;
-
-export async function ${functionName}(req: AggregateRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = res.locals.outputValidator?.schema || req.outputValidation;
-
-    const result = await req.prisma.${(0, strings_1.toPascalCase)(modelName)}.aggregate(req.query as ${argsTypeName});
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(result);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(result);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`;
-};
-exports.generateAggregateFunction = generateAggregateFunction;
-//# sourceMappingURL=generateAggregate.js.map

package/dist/helpers/generateAggregate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateAggregate.js","sourceRoot":"","sources":["../../src/helpers/generateAggregate.ts"],"names":[],"mappings":";;;AACA,8CAA2D;AASpD,MAAM,yBAAyB,GAAG,CAAC,OAGzC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,WAAW,CAAA;IAC5C,MAAM,YAAY,GAAG,UAAU,IAAA,oBAAU,EAAC,SAAS,CAAC,eAAe,CAAA;IAEnE,OAAO;EACP,qBAAqB;;;;;;;;;mBASJ,YAAY;;;;;;;kFAOmD,YAAY;;wBAEtE,YAAY;;;;sCAIE,IAAA,sBAAY,EAAC,SAAS,CAAC,2BAA2B,YAAY;;;;;;;;;;;;;;;EAelG,CAAA;AACF,CAAC,CAAA;AAhDY,QAAA,yBAAyB,6BAgDrC"}