@prisma-next/operations 0.5.0-dev.9 → 0.6.0-dev.1

package/README.md

@@ -9,10 +9,11 @@ This package provides a generic, target-neutral operation registry. It's part of
 ## Responsibilities
 
 - **Operation Registry**: Generic operation registry interface and implementation
-  - `OperationRegistry<T>`: Generic interface for registering and iterating operations, parameterized by entry type
+  - `OperationRegistry<T>`: Generic interface for registering and iterating operations, parameterized by entry type. `register(name, descriptor)` keys each entry by an explicit method name supplied at the call site.
   - `createOperationRegistry<T>()`: Factory function to create operation registries
-  - `OperationEntry`: Base entry type with `args` and `returns`
-  - `OperationDescriptor<T>`: Entry plus a `method` name, used for registration
+  - `OperationEntry`: Base entry type with `self` and `impl`
+  - `OperationDescriptor<T>`: Alias for the entry shape used at registration sites
+  - `OperationDescriptors<T>`: `Readonly<Record<string, OperationDescriptor<T>>>` — the natural shape contributors return, where the record key IS the method name
   - `ParamSpec`: Describes an operation parameter (`codecId`, `nullable`), used for both arguments and return values
 
 ## Dependencies
@@ -59,19 +60,18 @@ import { createOperationRegistry, type OperationDescriptor } from '@prisma-next/
 const registry = createOperationRegistry();
 
 const descriptor: OperationDescriptor = {
-  method: 'cosineDistance',
-  args: [{ codecId: 'pg/vector@1', nullable: false }],
-  returns: { codecId: 'pg/float8@1', nullable: false },
+  self: { codecId: 'pg/vector@1' },
+  impl: () => ({ returnType: { codecId: 'pg/float8@1', nullable: false } }),
 };
 
-registry.register(descriptor);
+registry.register('cosineDistance', descriptor);
 const entries = registry.entries(); // Record<string, OperationEntry>
 ```
 
 ### Using a Custom Entry Type
 
 ```typescript
-import { createOperationRegistry, type OperationEntry, type OperationDescriptor } from '@prisma-next/operations';
+import { createOperationRegistry, type OperationEntry } from '@prisma-next/operations';
 
 interface MyEntry extends OperationEntry {
   readonly extra: string;
@@ -79,10 +79,9 @@ interface MyEntry extends OperationEntry {
 
 const registry = createOperationRegistry<MyEntry>();
 
-registry.register({
-  method: 'myMethod',
-  args: [],
-  returns: { codecId: 'pg/int4@1', nullable: false },
+registry.register('myMethod', {
+  self: { codecId: 'pg/int4@1' },
+  impl: () => undefined as never,
   extra: 'custom data',
 });
 ```

package/dist/index.d.mts

@@ -8,18 +8,24 @@ interface ReturnSpec {
   readonly codecId: string;
   readonly nullable: boolean;
 }
+type SelfSpec = {
+  readonly codecId: string;
+  readonly traits?: never;
+} | {
+  readonly traits: readonly string[];
+  readonly codecId?: never;
+};
 interface OperationEntry {
-  readonly args: readonly ParamSpec[];
-  readonly returns: ReturnSpec;
+  readonly self?: SelfSpec;
+  readonly impl: (...args: never[]) => unknown;
 }
-type OperationDescriptor<T extends OperationEntry = OperationEntry> = T & {
-  readonly method: string;
-};
+type OperationDescriptor<T extends OperationEntry = OperationEntry> = T;
+type OperationDescriptors<T extends OperationEntry = OperationEntry> = Readonly<Record<string, OperationDescriptor<T>>>;
 interface OperationRegistry<T extends OperationEntry = OperationEntry> {
-  register(descriptor: OperationDescriptor<T>): void;
+  register(name: string, descriptor: OperationDescriptor<T>): void;
   entries(): Readonly<Record<string, T>>;
 }
 declare function createOperationRegistry<T extends OperationEntry = OperationEntry>(): OperationRegistry<T>;
 //#endregion
-export { OperationDescriptor, OperationEntry, OperationRegistry, ParamSpec, ReturnSpec, createOperationRegistry };
+export { OperationDescriptor, OperationDescriptors, OperationEntry, OperationRegistry, ParamSpec, ReturnSpec, SelfSpec, createOperationRegistry };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";UAAiB,SAAA;EAAA,SAAA,OAAS,CAAA,EAAA,MAAA;EAMT,SAAA,MAAU,CAAA,EAAA,SAAA,MAAA,EAAA;EAKV,SAAA,QAAc,EAAA,OAAA;AAK/B;AAA0C,UAVzB,UAAA,CAUyB;EAAiB,SAAA,OAAA,EAAA,MAAA;EAAkB,SAAA,QAAA,EAAA,OAAA;;AAI5D,UATA,cAAA,CASiB;EAAW,SAAA,IAAA,EAAA,SARnB,SAQmB,EAAA;EAAiB,SAAA,OAAA,EAP1C,UAO0C;;AACvC,KALX,mBAKW,CAAA,UALmB,cAKnB,GALoC,cAKpC,CAAA,GALsD,CAKtD,GAAA;EACc,SAAA,MAAA,EAAA,MAAA;CAAf;AAAT,UAFI,iBAEJ,CAAA,UAFgC,cAEhC,GAFiD,cAEjD,CAAA,CAAA;EAAQ,QAAA,CAAA,UAAA,EADE,mBACF,CADsB,CACtB,CAAA,CAAA,EAAA,IAAA;EAGL,OAAA,EAAA,EAHH,QAGG,CAHM,MAGiB,CAAA,MAAA,EAHF,CAGE,CAAA,CAAA;;AACV,iBADb,uBACa,CAAA,UAAjB,cAAiB,GAAA,cAAA,CAAA,CAAA,CAAA,EACxB,iBADwB,CACN,CADM,CAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";UAAiB,SAAA;EAAA,SACN,OAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA;AAAA;AAAA,UAGM,UAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA;AAAA;AAAA,KAGC,QAAA;EAAA,SACG,OAAA;EAAA,SAA0B,MAAA;AAAA;EAAA,SAC1B,MAAA;EAAA,SAAoC,OAAA;AAAA;AAAA,UAElC,cAAA;EAAA,SACN,IAAA,GAAO,QAAA;EAAA,SACP,IAAA,MAAU,IAAA;AAAA;AAAA,KAGT,mBAAA,WAA8B,cAAA,GAAiB,cAAA,IAAkB,CAAA;AAAA,KAEjE,oBAAA,WAA+B,cAAA,GAAiB,cAAA,IAAkB,QAAA,CAC5E,MAAA,SAAe,mBAAA,CAAoB,CAAA;AAAA,UAGpB,iBAAA,WAA4B,cAAA,GAAiB,cAAA;EAC5D,QAAA,CAAS,IAAA,UAAc,UAAA,EAAY,mBAAA,CAAoB,CAAA;EACvD,OAAA,IAAW,QAAA,CAAS,MAAA,SAAe,CAAA;AAAA;AAAA,iBAGrB,uBAAA,WACJ,cAAA,GAAiB,cAAA,CAAA,CAAA,GACxB,iBAAA,CAAkB,CAAA"}

package/dist/index.mjs

@@ -2,23 +2,22 @@
 function createOperationRegistry() {
 	const operations = Object.create(null);
 	return {
-		register(descriptor) {
-			if (descriptor.method in operations) throw new Error(`Operation "${descriptor.method}" is already registered`);
-			descriptor.args.forEach((arg, i) => {
-				const hasCodecId = arg.codecId !== void 0;
-				const hasTraits = arg.traits !== void 0 && arg.traits.length > 0;
-				if (!hasCodecId && !hasTraits) throw new Error(`Operation "${descriptor.method}" arg[${i}] has neither codecId nor traits`);
-				if (hasCodecId && hasTraits) throw new Error(`Operation "${descriptor.method}" arg[${i}] has both codecId and traits`);
-			});
-			const { method: _method, ...entry } = descriptor;
-			operations[descriptor.method] = entry;
+		register(name, descriptor) {
+			if (name in operations) throw new Error(`Operation "${name}" is already registered`);
+			if (descriptor.self) {
+				const hasCodecId = descriptor.self.codecId !== void 0;
+				const hasTraits = descriptor.self.traits !== void 0 && descriptor.self.traits.length > 0;
+				if (!hasCodecId && !hasTraits) throw new Error(`Operation "${name}" self has neither codecId nor traits`);
+				if (hasCodecId && hasTraits) throw new Error(`Operation "${name}" self has both codecId and traits`);
+			}
+			operations[name] = descriptor;
 		},
 		entries() {
 			return Object.freeze({ ...operations });
 		}
 	};
 }
-
 //#endregion
 export { createOperationRegistry };
+
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["operations: Record<string, T>"],"sources":["../src/index.ts"],"sourcesContent":["export interface ParamSpec {\n  readonly codecId?: string;\n  readonly traits?: readonly string[];\n  readonly nullable: boolean;\n}\n\nexport interface ReturnSpec {\n  readonly codecId: string;\n  readonly nullable: boolean;\n}\n\nexport interface OperationEntry {\n  readonly args: readonly ParamSpec[];\n  readonly returns: ReturnSpec;\n}\n\nexport type OperationDescriptor<T extends OperationEntry = OperationEntry> = T & {\n  readonly method: string;\n};\n\nexport interface OperationRegistry<T extends OperationEntry = OperationEntry> {\n  register(descriptor: OperationDescriptor<T>): void;\n  entries(): Readonly<Record<string, T>>;\n}\n\nexport function createOperationRegistry<\n  T extends OperationEntry = OperationEntry,\n>(): OperationRegistry<T> {\n  const operations: Record<string, T> = Object.create(null);\n\n  return {\n    register(descriptor: OperationDescriptor<T>) {\n      if (descriptor.method in operations) {\n        throw new Error(`Operation \"${descriptor.method}\" is already registered`);\n      }\n      descriptor.args.forEach((arg, i) => {\n        const hasCodecId = arg.codecId !== undefined;\n        const hasTraits = arg.traits !== undefined && arg.traits.length > 0;\n        if (!hasCodecId && !hasTraits) {\n          throw new Error(\n            `Operation \"${descriptor.method}\" arg[${i}] has neither codecId nor traits`,\n          );\n        }\n        if (hasCodecId && hasTraits) {\n          throw new Error(`Operation \"${descriptor.method}\" arg[${i}] has both codecId and traits`);\n        }\n      });\n      const { method: _method, ...entry } = descriptor;\n      // OperationDescriptor<T> = T & { method }, so stripping method yields T.\n      // TypeScript can't prove Omit<T & { method }, 'method'> = T for generic T.\n      operations[descriptor.method] = entry as unknown as T;\n    },\n    entries() {\n      return Object.freeze({ ...operations });\n    },\n  };\n}\n"],"mappings":";AAyBA,SAAgB,0BAEU;CACxB,MAAMA,aAAgC,OAAO,OAAO,KAAK;AAEzD,QAAO;EACL,SAAS,YAAoC;AAC3C,OAAI,WAAW,UAAU,WACvB,OAAM,IAAI,MAAM,cAAc,WAAW,OAAO,yBAAyB;AAE3E,cAAW,KAAK,SAAS,KAAK,MAAM;IAClC,MAAM,aAAa,IAAI,YAAY;IACnC,MAAM,YAAY,IAAI,WAAW,UAAa,IAAI,OAAO,SAAS;AAClE,QAAI,CAAC,cAAc,CAAC,UAClB,OAAM,IAAI,MACR,cAAc,WAAW,OAAO,QAAQ,EAAE,kCAC3C;AAEH,QAAI,cAAc,UAChB,OAAM,IAAI,MAAM,cAAc,WAAW,OAAO,QAAQ,EAAE,+BAA+B;KAE3F;GACF,MAAM,EAAE,QAAQ,SAAS,GAAG,UAAU;AAGtC,cAAW,WAAW,UAAU;;EAElC,UAAU;AACR,UAAO,OAAO,OAAO,EAAE,GAAG,YAAY,CAAC;;EAE1C"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export interface ParamSpec {\n  readonly codecId?: string;\n  readonly traits?: readonly string[];\n  readonly nullable: boolean;\n}\n\nexport interface ReturnSpec {\n  readonly codecId: string;\n  readonly nullable: boolean;\n}\n\nexport type SelfSpec =\n  | { readonly codecId: string; readonly traits?: never }\n  | { readonly traits: readonly string[]; readonly codecId?: never };\n\nexport interface OperationEntry {\n  readonly self?: SelfSpec;\n  readonly impl: (...args: never[]) => unknown;\n}\n\nexport type OperationDescriptor<T extends OperationEntry = OperationEntry> = T;\n\nexport type OperationDescriptors<T extends OperationEntry = OperationEntry> = Readonly<\n  Record<string, OperationDescriptor<T>>\n>;\n\nexport interface OperationRegistry<T extends OperationEntry = OperationEntry> {\n  register(name: string, descriptor: OperationDescriptor<T>): void;\n  entries(): Readonly<Record<string, T>>;\n}\n\nexport function createOperationRegistry<\n  T extends OperationEntry = OperationEntry,\n>(): OperationRegistry<T> {\n  const operations: Record<string, T> = Object.create(null);\n\n  return {\n    register(name: string, descriptor: OperationDescriptor<T>) {\n      if (name in operations) {\n        throw new Error(`Operation \"${name}\" is already registered`);\n      }\n      if (descriptor.self) {\n        const hasCodecId = descriptor.self.codecId !== undefined;\n        const hasTraits = descriptor.self.traits !== undefined && descriptor.self.traits.length > 0;\n        if (!hasCodecId && !hasTraits) {\n          throw new Error(`Operation \"${name}\" self has neither codecId nor traits`);\n        }\n        if (hasCodecId && hasTraits) {\n          throw new Error(`Operation \"${name}\" self has both codecId and traits`);\n        }\n      }\n      operations[name] = descriptor;\n    },\n    entries() {\n      return Object.freeze({ ...operations });\n    },\n  };\n}\n"],"mappings":";AA+BA,SAAgB,0BAEU;CACxB,MAAM,aAAgC,OAAO,OAAO,KAAK;CAEzD,OAAO;EACL,SAAS,MAAc,YAAoC;GACzD,IAAI,QAAQ,YACV,MAAM,IAAI,MAAM,cAAc,KAAK,yBAAyB;GAE9D,IAAI,WAAW,MAAM;IACnB,MAAM,aAAa,WAAW,KAAK,YAAY,KAAA;IAC/C,MAAM,YAAY,WAAW,KAAK,WAAW,KAAA,KAAa,WAAW,KAAK,OAAO,SAAS;IAC1F,IAAI,CAAC,cAAc,CAAC,WAClB,MAAM,IAAI,MAAM,cAAc,KAAK,uCAAuC;IAE5E,IAAI,cAAc,WAChB,MAAM,IAAI,MAAM,cAAc,KAAK,oCAAoC;;GAG3E,WAAW,QAAQ;;EAErB,UAAU;GACR,OAAO,OAAO,OAAO,EAAE,GAAG,YAAY,CAAC;;EAE1C"}

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@prisma-next/operations",
-  "version": "0.5.0-dev.9",
+  "version": "0.6.0-dev.1",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Target-neutral operation registry and capability helpers for Prisma Next",
   "dependencies": {},
   "devDependencies": {
-    "tsdown": "0.18.4",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.17",
+    "vitest": "4.1.5",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsdown": "0.0.0"

package/src/index.ts

@@ -9,17 +9,23 @@ export interface ReturnSpec {
   readonly nullable: boolean;
 }
 
+export type SelfSpec =
+  | { readonly codecId: string; readonly traits?: never }
+  | { readonly traits: readonly string[]; readonly codecId?: never };
+
 export interface OperationEntry {
-  readonly args: readonly ParamSpec[];
-  readonly returns: ReturnSpec;
+  readonly self?: SelfSpec;
+  readonly impl: (...args: never[]) => unknown;
 }
 
-export type OperationDescriptor<T extends OperationEntry = OperationEntry> = T & {
-  readonly method: string;
-};
+export type OperationDescriptor<T extends OperationEntry = OperationEntry> = T;
+
+export type OperationDescriptors<T extends OperationEntry = OperationEntry> = Readonly<
+  Record<string, OperationDescriptor<T>>
+>;
 
 export interface OperationRegistry<T extends OperationEntry = OperationEntry> {
-  register(descriptor: OperationDescriptor<T>): void;
+  register(name: string, descriptor: OperationDescriptor<T>): void;
   entries(): Readonly<Record<string, T>>;
 }
 
@@ -29,26 +35,21 @@ export function createOperationRegistry<
   const operations: Record<string, T> = Object.create(null);
 
   return {
-    register(descriptor: OperationDescriptor<T>) {
-      if (descriptor.method in operations) {
-        throw new Error(`Operation "${descriptor.method}" is already registered`);
+    register(name: string, descriptor: OperationDescriptor<T>) {
+      if (name in operations) {
+        throw new Error(`Operation "${name}" is already registered`);
       }
-      descriptor.args.forEach((arg, i) => {
-        const hasCodecId = arg.codecId !== undefined;
-        const hasTraits = arg.traits !== undefined && arg.traits.length > 0;
+      if (descriptor.self) {
+        const hasCodecId = descriptor.self.codecId !== undefined;
+        const hasTraits = descriptor.self.traits !== undefined && descriptor.self.traits.length > 0;
         if (!hasCodecId && !hasTraits) {
-          throw new Error(
-            `Operation "${descriptor.method}" arg[${i}] has neither codecId nor traits`,
-          );
+          throw new Error(`Operation "${name}" self has neither codecId nor traits`);
         }
         if (hasCodecId && hasTraits) {
-          throw new Error(`Operation "${descriptor.method}" arg[${i}] has both codecId and traits`);
+          throw new Error(`Operation "${name}" self has both codecId and traits`);
         }
-      });
-      const { method: _method, ...entry } = descriptor;
-      // OperationDescriptor<T> = T & { method }, so stripping method yields T.
-      // TypeScript can't prove Omit<T & { method }, 'method'> = T for generic T.
-      operations[descriptor.method] = entry as unknown as T;
+      }
+      operations[name] = descriptor;
     },
     entries() {
       return Object.freeze({ ...operations });