@prisma/client-engine-runtime 6.6.0-dev.70 → 6.6.0-dev.72

package/dist/QueryPlan.d.ts

@@ -6,7 +6,15 @@ export type PrismaValuePlaceholder = {
     };
 };
 export declare function isPrismaValuePlaceholder(value: unknown): value is PrismaValuePlaceholder;
-export type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder;
+export type PrismaValueGenerator = {
+    prisma__type: 'generatorCall';
+    prisma__value: {
+        name: string;
+        args: PrismaValue[];
+    };
+};
+export declare function isPrismaValueGenerator(value: unknown): value is PrismaValueGenerator;
+export type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator;
 export type QueryPlanBinding = {
     name: string;
     expr: QueryPlanNode;

package/dist/index.d.mts

@@ -12,6 +12,8 @@ export declare type Fragment = {
     type: 'parameterTuple';
 };
 
+export declare function isPrismaValueGenerator(value: unknown): value is PrismaValueGenerator;
+
 export declare function isPrismaValuePlaceholder(value: unknown): value is PrismaValuePlaceholder;
 
 export declare type JoinExpression = {
@@ -25,7 +27,15 @@ export declare interface PlaceholderFormat {
     hasNumbering: boolean;
 }
 
-export declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder;
+export declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator;
+
+export declare type PrismaValueGenerator = {
+    prisma__type: 'generatorCall';
+    prisma__value: {
+        name: string;
+        args: PrismaValue[];
+    };
+};
 
 export declare type PrismaValuePlaceholder = {
     prisma__type: 'param';

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export declare type Fragment = {
     type: 'parameterTuple';
 };
 
+export declare function isPrismaValueGenerator(value: unknown): value is PrismaValueGenerator;
+
 export declare function isPrismaValuePlaceholder(value: unknown): value is PrismaValuePlaceholder;
 
 export declare type JoinExpression = {
@@ -25,7 +27,15 @@ export declare interface PlaceholderFormat {
     hasNumbering: boolean;
 }
 
-export declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder;
+export declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator;
+
+export declare type PrismaValueGenerator = {
+    prisma__type: 'generatorCall';
+    prisma__value: {
+        name: string;
+        args: PrismaValue[];
+    };
+};
 
 export declare type PrismaValuePlaceholder = {
     prisma__type: 'param';

package/dist/index.js

@@ -33,14 +33,95 @@ __export(index_exports, {
   QueryInterpreter: () => QueryInterpreter,
   TransactionManager: () => TransactionManager,
   TransactionManagerError: () => TransactionManagerError,
+  isPrismaValueGenerator: () => isPrismaValueGenerator,
   isPrismaValuePlaceholder: () => isPrismaValuePlaceholder
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/interpreter/generators.ts
+var import_cuid = __toESM(require("@bugsnag/cuid"));
+var import_cuid2 = require("@paralleldrive/cuid2");
+var import_nanoid = require("nanoid");
+var import_ulid = require("ulid");
+var import_uuid = require("uuid");
+var GeneratorRegistry = class {
+  #generators = {};
+  constructor() {
+    this.register("now", new NowGenerator());
+    this.register("uuid", new UuidGenerator());
+    this.register("cuid", new CuidGenerator());
+    this.register("ulid", new UlidGenerator());
+    this.register("nanoid", new NanoIdGenerator());
+  }
+  /**
+   * Returns a snapshot of the generator registry. It's 'frozen' in time at the moment of this
+   * method being called, meaning that the built-in time-based generators will always return
+   * the same value on repeated calls as long as the same snapshot is used.
+   */
+  snapshot() {
+    return Object.create(this.#generators, {
+      now: { value: new NowGenerator() }
+    });
+  }
+  /**
+   * Registers a new generator with the given name.
+   */
+  register(name, generator) {
+    this.#generators[name] = generator;
+  }
+};
+var NowGenerator = class {
+  #now = /* @__PURE__ */ new Date();
+  generate() {
+    return this.#now.toISOString();
+  }
+};
+var UuidGenerator = class {
+  generate(arg) {
+    if (arg === 4) {
+      return (0, import_uuid.v4)();
+    } else if (arg === 7) {
+      return (0, import_uuid.v7)();
+    } else {
+      throw new Error("Invalid UUID generator arguments");
+    }
+  }
+};
+var CuidGenerator = class {
+  generate(arg) {
+    if (arg === 1) {
+      return (0, import_cuid.default)();
+    } else if (arg === 2) {
+      return (0, import_cuid2.createId)();
+    } else {
+      throw new Error("Invalid CUID generator arguments");
+    }
+  }
+};
+var UlidGenerator = class {
+  generate() {
+    return (0, import_ulid.ulid)();
+  }
+};
+var NanoIdGenerator = class {
+  generate(arg) {
+    if (typeof arg === "number") {
+      return (0, import_nanoid.nanoid)(arg);
+    } else if (arg === void 0) {
+      return (0, import_nanoid.nanoid)();
+    } else {
+      throw new Error("Invalid Nanoid generator arguments");
+    }
+  }
+};
+
 // src/QueryPlan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
+function isPrismaValueGenerator(value) {
+  return typeof value === "object" && value !== null && value["prisma__type"] === "generatorCall";
+}
 
 // src/utils.ts
 function assertNever(_, message) {
@@ -48,19 +129,31 @@ function assertNever(_, message) {
 }
 
 // src/interpreter/renderQuery.ts
-function renderQuery(dbQuery, scope) {
+function renderQuery(dbQuery, scope, generators) {
   const queryType = dbQuery.type;
   switch (queryType) {
     case "rawSql":
-      return renderRawSql(dbQuery.sql, substituteParams(dbQuery.params, scope));
+      return renderRawSql(dbQuery.sql, substituteParams(dbQuery.params, scope, generators));
     case "templateSql":
-      return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, substituteParams(dbQuery.params, scope));
+      return renderTemplateSql(
+        dbQuery.fragments,
+        dbQuery.placeholderFormat,
+        substituteParams(dbQuery.params, scope, generators)
+      );
     default:
       assertNever(queryType, `Invalid query type`);
   }
 }
-function substituteParams(params, scope) {
+function substituteParams(params, scope, generators) {
   return params.map((param) => {
+    if (isPrismaValueGenerator(param)) {
+      const { name, args } = param.prisma__value;
+      const generator = generators[name];
+      if (!generator) {
+        throw new Error(`Encountered an unknown generator '${name}'`);
+      }
+      return generator.generate(...args);
+    }
     if (!isPrismaValuePlaceholder(param)) {
       return param;
     }
@@ -184,18 +277,19 @@ var QueryInterpreter = class {
   #queryable;
   #placeholderValues;
   #onQuery;
+  #generators = new GeneratorRegistry();
   constructor({ queryable, placeholderValues, onQuery }) {
     this.#queryable = queryable;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
   }
   async run(queryPlan) {
-    return this.interpretNode(queryPlan, this.#placeholderValues);
+    return this.interpretNode(queryPlan, this.#placeholderValues, this.#generators.snapshot());
   }
-  async interpretNode(node, scope) {
+  async interpretNode(node, scope, generators) {
     switch (node.type) {
       case "seq": {
-        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return results[results.length - 1];
       }
       case "get": {
@@ -205,10 +299,10 @@ var QueryInterpreter = class {
         const nestedScope = Object.create(scope);
         await Promise.all(
           node.args.bindings.map(async (binding) => {
-            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope);
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope, generators);
           })
         );
-        return this.interpretNode(node.args.expr, nestedScope);
+        return this.interpretNode(node.args.expr, nestedScope, generators);
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
@@ -220,31 +314,31 @@ var QueryInterpreter = class {
         return [];
       }
       case "concat": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return parts.reduce((acc, part) => acc.concat(asList(part)), []);
       }
       case "sum": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
       }
       case "execute": {
-        const query = renderQuery(node.args, scope);
+        const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
           return await this.#queryable.executeRaw(query);
         });
       }
       case "query": {
-        const query = renderQuery(node.args, scope);
+        const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
           return serialize(await this.#queryable.queryRaw(query));
         });
       }
       case "reverse": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         return Array.isArray(value) ? value.reverse() : value;
       }
       case "unique": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         if (!Array.isArray(value)) {
           return value;
         }
@@ -254,22 +348,22 @@ var QueryInterpreter = class {
         return value[0] ?? null;
       }
       case "required": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return value;
       }
       case "mapField": {
-        const value = await this.interpretNode(node.args.records, scope);
+        const value = await this.interpretNode(node.args.records, scope, generators);
         return mapField(value, node.args.field);
       }
       case "join": {
-        const parent = await this.interpretNode(node.args.parent, scope);
+        const parent = await this.interpretNode(node.args.parent, scope, generators);
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: await this.interpretNode(joinExpr.child, scope)
+            childRecords: await this.interpretNode(joinExpr.child, scope, generators)
           }))
         );
         if (Array.isArray(parent)) {
@@ -585,5 +679,6 @@ var TransactionManager = class {
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
+  isPrismaValueGenerator,
   isPrismaValuePlaceholder
 });

package/dist/index.mjs

@@ -1,7 +1,87 @@
+// src/interpreter/generators.ts
+import cuid1 from "@bugsnag/cuid";
+import { createId as cuid2 } from "@paralleldrive/cuid2";
+import { nanoid } from "nanoid";
+import { ulid } from "ulid";
+import { v4 as uuidv4, v7 as uuidv7 } from "uuid";
+var GeneratorRegistry = class {
+  #generators = {};
+  constructor() {
+    this.register("now", new NowGenerator());
+    this.register("uuid", new UuidGenerator());
+    this.register("cuid", new CuidGenerator());
+    this.register("ulid", new UlidGenerator());
+    this.register("nanoid", new NanoIdGenerator());
+  }
+  /**
+   * Returns a snapshot of the generator registry. It's 'frozen' in time at the moment of this
+   * method being called, meaning that the built-in time-based generators will always return
+   * the same value on repeated calls as long as the same snapshot is used.
+   */
+  snapshot() {
+    return Object.create(this.#generators, {
+      now: { value: new NowGenerator() }
+    });
+  }
+  /**
+   * Registers a new generator with the given name.
+   */
+  register(name, generator) {
+    this.#generators[name] = generator;
+  }
+};
+var NowGenerator = class {
+  #now = /* @__PURE__ */ new Date();
+  generate() {
+    return this.#now.toISOString();
+  }
+};
+var UuidGenerator = class {
+  generate(arg) {
+    if (arg === 4) {
+      return uuidv4();
+    } else if (arg === 7) {
+      return uuidv7();
+    } else {
+      throw new Error("Invalid UUID generator arguments");
+    }
+  }
+};
+var CuidGenerator = class {
+  generate(arg) {
+    if (arg === 1) {
+      return cuid1();
+    } else if (arg === 2) {
+      return cuid2();
+    } else {
+      throw new Error("Invalid CUID generator arguments");
+    }
+  }
+};
+var UlidGenerator = class {
+  generate() {
+    return ulid();
+  }
+};
+var NanoIdGenerator = class {
+  generate(arg) {
+    if (typeof arg === "number") {
+      return nanoid(arg);
+    } else if (arg === void 0) {
+      return nanoid();
+    } else {
+      throw new Error("Invalid Nanoid generator arguments");
+    }
+  }
+};
+
 // src/QueryPlan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
+function isPrismaValueGenerator(value) {
+  return typeof value === "object" && value !== null && value["prisma__type"] === "generatorCall";
+}
 
 // src/utils.ts
 function assertNever(_, message) {
@@ -9,19 +89,31 @@ function assertNever(_, message) {
 }
 
 // src/interpreter/renderQuery.ts
-function renderQuery(dbQuery, scope) {
+function renderQuery(dbQuery, scope, generators) {
   const queryType = dbQuery.type;
   switch (queryType) {
     case "rawSql":
-      return renderRawSql(dbQuery.sql, substituteParams(dbQuery.params, scope));
+      return renderRawSql(dbQuery.sql, substituteParams(dbQuery.params, scope, generators));
     case "templateSql":
-      return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, substituteParams(dbQuery.params, scope));
+      return renderTemplateSql(
+        dbQuery.fragments,
+        dbQuery.placeholderFormat,
+        substituteParams(dbQuery.params, scope, generators)
+      );
     default:
       assertNever(queryType, `Invalid query type`);
   }
 }
-function substituteParams(params, scope) {
+function substituteParams(params, scope, generators) {
   return params.map((param) => {
+    if (isPrismaValueGenerator(param)) {
+      const { name, args } = param.prisma__value;
+      const generator = generators[name];
+      if (!generator) {
+        throw new Error(`Encountered an unknown generator '${name}'`);
+      }
+      return generator.generate(...args);
+    }
     if (!isPrismaValuePlaceholder(param)) {
       return param;
     }
@@ -145,18 +237,19 @@ var QueryInterpreter = class {
   #queryable;
   #placeholderValues;
   #onQuery;
+  #generators = new GeneratorRegistry();
   constructor({ queryable, placeholderValues, onQuery }) {
     this.#queryable = queryable;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
   }
   async run(queryPlan) {
-    return this.interpretNode(queryPlan, this.#placeholderValues);
+    return this.interpretNode(queryPlan, this.#placeholderValues, this.#generators.snapshot());
   }
-  async interpretNode(node, scope) {
+  async interpretNode(node, scope, generators) {
     switch (node.type) {
       case "seq": {
-        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return results[results.length - 1];
       }
       case "get": {
@@ -166,10 +259,10 @@ var QueryInterpreter = class {
         const nestedScope = Object.create(scope);
         await Promise.all(
           node.args.bindings.map(async (binding) => {
-            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope);
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope, generators);
           })
         );
-        return this.interpretNode(node.args.expr, nestedScope);
+        return this.interpretNode(node.args.expr, nestedScope, generators);
       }
       case "getFirstNonEmpty": {
         for (const name of node.args.names) {
@@ -181,31 +274,31 @@ var QueryInterpreter = class {
         return [];
       }
       case "concat": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return parts.reduce((acc, part) => acc.concat(asList(part)), []);
       }
       case "sum": {
-        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope, generators)));
         return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
       }
       case "execute": {
-        const query = renderQuery(node.args, scope);
+        const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
           return await this.#queryable.executeRaw(query);
         });
       }
       case "query": {
-        const query = renderQuery(node.args, scope);
+        const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, async () => {
           return serialize(await this.#queryable.queryRaw(query));
         });
       }
       case "reverse": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         return Array.isArray(value) ? value.reverse() : value;
       }
       case "unique": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         if (!Array.isArray(value)) {
           return value;
         }
@@ -215,22 +308,22 @@ var QueryInterpreter = class {
         return value[0] ?? null;
       }
       case "required": {
-        const value = await this.interpretNode(node.args, scope);
+        const value = await this.interpretNode(node.args, scope, generators);
         if (isEmpty(value)) {
           throw new Error("Required value is empty");
         }
         return value;
       }
       case "mapField": {
-        const value = await this.interpretNode(node.args.records, scope);
+        const value = await this.interpretNode(node.args.records, scope, generators);
         return mapField(value, node.args.field);
       }
       case "join": {
-        const parent = await this.interpretNode(node.args.parent, scope);
+        const parent = await this.interpretNode(node.args.parent, scope, generators);
         const children = await Promise.all(
           node.args.children.map(async (joinExpr) => ({
             joinExpr,
-            childRecords: await this.interpretNode(joinExpr.child, scope)
+            childRecords: await this.interpretNode(joinExpr.child, scope, generators)
           }))
         );
         if (Array.isArray(parent)) {
@@ -545,5 +638,6 @@ export {
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
+  isPrismaValueGenerator,
   isPrismaValuePlaceholder
 };

package/dist/interpreter/generators.d.ts

@@ -0,0 +1,21 @@
+import { PrismaValue } from '../QueryPlan';
+export declare class GeneratorRegistry {
+    #private;
+    constructor();
+    /**
+     * Returns a snapshot of the generator registry. It's 'frozen' in time at the moment of this
+     * method being called, meaning that the built-in time-based generators will always return
+     * the same value on repeated calls as long as the same snapshot is used.
+     */
+    snapshot(): Readonly<GeneratorRegistrySnapshot>;
+    /**
+     * Registers a new generator with the given name.
+     */
+    register(name: string, generator: ValueGenerator): void;
+}
+export interface GeneratorRegistrySnapshot {
+    [key: string]: ValueGenerator;
+}
+export interface ValueGenerator {
+    generate(...args: PrismaValue[]): PrismaValue;
+}

package/dist/interpreter/generators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/interpreter/renderQuery.d.ts

@@ -1,4 +1,5 @@
 import { SqlQuery } from '@prisma/driver-adapter-utils';
 import type { QueryPlanDbQuery } from '../QueryPlan';
+import { GeneratorRegistrySnapshot } from './generators';
 import { ScopeBindings } from './scope';
-export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings): SqlQuery;
+export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): SqlQuery;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.6.0-dev.70",
+  "version": "6.6.0-dev.72",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,8 +24,13 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@prisma/debug": "6.6.0-dev.70",
-    "@prisma/driver-adapter-utils": "6.6.0-dev.70"
+    "@bugsnag/cuid": "3.2.1",
+    "@paralleldrive/cuid2": "2.2.2",
+    "nanoid": "5.1.5",
+    "ulid": "3.0.0",
+    "uuid": "11.1.0",
+    "@prisma/debug": "6.6.0-dev.72",
+    "@prisma/driver-adapter-utils": "6.6.0-dev.72"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",