@prisma-next/operations 0.3.0-dev.145 → 0.3.0-dev.146

package/README.md

@@ -1,29 +1,28 @@
 # @prisma-next/operations
 
-Target-neutral operation registry and capability helpers for Prisma Next.
+Target-neutral operation registry for Prisma Next.
 
 ## Overview
 
-This package provides target-neutral operation registry types and capability checking utilities. It's part of the core ring and has no dependencies on target-specific packages.
+This package provides a generic, target-neutral operation registry. It's part of the core ring and has no dependencies on target-specific packages.
 
 ## Responsibilities
 
-- **Operation Registry**: Core operation registry interface and implementation
-  - `OperationRegistry`: Interface for registering and querying operations
-  - `createOperationRegistry()`: Factory function to create operation registries
-  - `OperationSignature`: Core operation signature type (target-neutral)
-  - `ArgSpec`, `ReturnSpec`: Type definitions for operation arguments and return values
-
-- **Capability Checking**: Target-neutral capability validation
-  - `hasAllCapabilities()`: Checks if all required capabilities are present in a contract
+- **Operation Registry**: Generic operation registry interface and implementation
+  - `OperationRegistry<T>`: Generic interface for registering and iterating operations, parameterized by entry type
+  - `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
+  - `ParamSpec`: Describes an operation parameter (`codecId`, `nullable`), used for both arguments and return values
 
 ## Dependencies
 
-- **Note**: This package has no runtime dependencies. `OperationRegistry` is used by contract types, but operations package itself has no contract dependencies.
+
+- **Depends on**: Nothing (leaf package)
 - **Depended on by**:
   - `@prisma-next/sql-operations` (extends with SQL-specific lowering specs)
-  - `@prisma-next/sql-relational-core` (uses for capability checking)
-  - `@prisma-next/runtime` (uses for operation registry creation)
+  - `@prisma-next/sql-relational-core` (imports `ParamSpec` for AST and type definitions)
+  - `@prisma-next/runtime-executor` (uses for operation registry creation)
 
 ## Architecture
 
@@ -55,36 +54,37 @@ flowchart TD
 ### Creating an Operation Registry
 
 ```typescript
-import { createOperationRegistry, type OperationSignature } from '@prisma-next/operations';
+import { createOperationRegistry, type OperationDescriptor } from '@prisma-next/operations';
 
 const registry = createOperationRegistry();
 
-const signature: OperationSignature = {
-  forTypeId: 'pg/vector@1',
+const descriptor: OperationDescriptor = {
   method: 'cosineDistance',
-  args: [{ kind: 'typeId', type: 'pg/vector@1' }],
-  returns: { kind: 'builtin', type: 'number' },
+  args: [{ codecId: 'pg/vector@1', nullable: false }],
+  returns: { codecId: 'pg/float8@1', nullable: false },
 };
 
-registry.register(signature);
-const operations = registry.byType('pg/vector@1');
+registry.register(descriptor);
+const entries = registry.entries(); // Record<string, OperationEntry>
 ```
 
-### Checking Capabilities
+### Using a Custom Entry Type
 
 ```typescript
-import { hasAllCapabilities } from '@prisma-next/operations';
+import { createOperationRegistry, type OperationEntry, type OperationDescriptor } from '@prisma-next/operations';
 
-const contractCapabilities = {
-  pgvector: {
-    'index.ivfflat': true,
-  },
-};
+interface MyEntry extends OperationEntry {
+  readonly extra: string;
+}
+
+const registry = createOperationRegistry<MyEntry>();
 
-const hasCapability = hasAllCapabilities(
-  ['pgvector.index.ivfflat'],
-  contractCapabilities,
-);
+registry.register({
+  method: 'myMethod',
+  args: [],
+  returns: { codecId: 'pg/int4@1', nullable: false },
+  extra: 'custom data',
+});
 ```
 
 ## Package Location

package/dist/index.d.mts

@@ -1,32 +1,20 @@
 //#region src/index.d.ts
-type ArgSpec = {
-  readonly kind: 'typeId';
-  readonly type: string;
-} | {
-  readonly kind: 'param';
-} | {
-  readonly kind: 'literal';
-};
-type ReturnSpec = {
-  readonly kind: 'typeId';
-  readonly type: string;
-} | {
-  readonly kind: 'builtin';
-  readonly type: 'number' | 'boolean' | 'string';
-};
-interface OperationSignature {
-  readonly forTypeId: string;
-  readonly method: string;
-  readonly args: ReadonlyArray<ArgSpec>;
-  readonly returns: ReturnSpec;
-  readonly capabilities?: ReadonlyArray<string>;
+interface ParamSpec {
+  readonly codecId: string;
+  readonly nullable: boolean;
 }
-interface OperationRegistry<T extends OperationSignature = OperationSignature> {
-  register(op: T): void;
-  byType(typeId: string): ReadonlyArray<T>;
+interface OperationEntry {
+  readonly args: readonly ParamSpec[];
+  readonly returns: ParamSpec;
+}
+type OperationDescriptor<T extends OperationEntry = OperationEntry> = T & {
+  readonly method: string;
+};
+interface OperationRegistry<T extends OperationEntry = OperationEntry> {
+  register(descriptor: OperationDescriptor<T>): void;
+  entries(): Readonly<Record<string, T>>;
 }
-declare function createOperationRegistry<T extends OperationSignature = OperationSignature>(): OperationRegistry<T>;
-declare function hasAllCapabilities(capabilities: ReadonlyArray<string>, contractCapabilities?: Record<string, Record<string, boolean>>): boolean;
+declare function createOperationRegistry<T extends OperationEntry = OperationEntry>(): OperationRegistry<T>;
 //#endregion
-export { ArgSpec, OperationRegistry, OperationSignature, ReturnSpec, createOperationRegistry, hasAllCapabilities };
+export { OperationDescriptor, OperationEntry, OperationRegistry, ParamSpec, 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":";KAAY,OAAA;EAAA,SAAA,IAAO,EAAA,QAAA;EAKP,SAAA,IAAU,EAAA,MAAA;AAItB,CAAA,GAAiB;EAGc,SAAA,IAAA,EAAA,OAAA;CAAd,GAAA;EACG,SAAA,IAAA,EAAA,SAAA;CACM;AAAa,KAT3B,UAAA,GAS2B;EAGtB,SAAA,IAAA,EAAA,QAAiB;EAAW,SAAA,IAAA,EAAA,MAAA;CAAqB,GAAA;EACnD,SAAA,IAAA,EAAA,SAAA;EACyB,SAAA,IAAA,EAAA,QAAA,GAAA,SAAA,GAAA,QAAA;CAAd;AAAa,UAVtB,kBAAA,CAUsB;EAyBvB,SAAA,SAAA,EAAA,MAAuB;EAC3B,SAAA,MAAA,EAAA,MAAA;EAAqB,SAAA,IAAA,EAjChB,aAiCgB,CAjCF,OAiCE,CAAA;EACV,SAAA,OAAA,EAjCH,UAiCG;EAAlB,SAAA,YAAA,CAAA,EAhCqB,aAgCrB,CAAA,MAAA,CAAA;;AAIW,UAjCC,iBAiCiB,CAAA,UAjCW,kBAiCX,GAjCgC,kBAiChC,CAAA,CAAA;EAClB,QAAA,CAAA,EAAA,EAjCD,CAiCC,CAAA,EAAA,IAAA;EACwB,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA,EAjCd,aAiCc,CAjCA,CAiCA,CAAA;;AAAT,iBARf,uBAQe,CAAA,UAPnB,kBAOmB,GAPE,kBAOF,CAAA,CAAA,CAAA,EAN1B,iBAM0B,CANR,CAMQ,CAAA;iBAFf,kBAAA,eACA,8CACS,eAAe"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";UAAiB,SAAA;EAAA,SAAA,OAAS,EAAA,MAAA;EAKT,SAAA,QAAc,EAAA,OAAA;AAK/B;AAA0C,UALzB,cAAA,CAKyB;EAAiB,SAAA,IAAA,EAAA,SAJjC,SAIiC,EAAA;EAAkB,SAAA,OAAA,EAHzD,SAGyD;;AAI5D,KAJL,mBAIsB,CAAA,UAJQ,cAIR,GAJyB,cAIzB,CAAA,GAJ2C,CAI3C,GAAA;EAAW,SAAA,MAAA,EAAA,MAAA;CAAiB;AACnB,UAD1B,iBAC0B,CAAA,UADE,cACF,GADmB,cACnB,CAAA,CAAA;EAApB,QAAA,CAAA,UAAA,EAAA,mBAAA,CAAoB,CAApB,CAAA,CAAA,EAAA,IAAA;EACc,OAAA,EAAA,EAAxB,QAAwB,CAAf,MAAe,CAAA,MAAA,EAAA,CAAA,CAAA,CAAA;;AAAxB,iBAGG,uBAHH,CAAA,UAID,cAJC,GAIgB,cAJhB,CAAA,CAAA,CAAA,EAKR,iBALQ,CAKU,CALV,CAAA"}

package/dist/index.mjs

@@ -1,28 +1,18 @@
 //#region src/index.ts
-var OperationRegistryImpl = class {
-	operations = /* @__PURE__ */ new Map();
-	register(op) {
-		const existing = this.operations.get(op.forTypeId) ?? [];
-		if (existing.find((existingOp) => existingOp.method === op.method)) throw new Error(`Operation method "${op.method}" already registered for typeId "${op.forTypeId}"`);
-		existing.push(op);
-		this.operations.set(op.forTypeId, existing);
-	}
-	byType(typeId) {
-		return this.operations.get(typeId) ?? [];
-	}
-};
 function createOperationRegistry() {
-	return new OperationRegistryImpl();
-}
-function hasAllCapabilities(capabilities, contractCapabilities) {
-	if (!contractCapabilities) return false;
-	return capabilities.every((cap) => {
-		const [namespace, ...rest] = cap.split(".");
-		const key = rest.join(".");
-		return (namespace ? contractCapabilities[namespace] : void 0)?.[key] === true;
-	});
+	const operations = Object.create(null);
+	return {
+		register(descriptor) {
+			if (descriptor.method in operations) throw new Error(`Operation "${descriptor.method}" is already registered`);
+			const { method: _method, ...entry } = descriptor;
+			operations[descriptor.method] = entry;
+		},
+		entries() {
+			return Object.freeze({ ...operations });
+		}
+	};
 }
 
 //#endregion
-export { createOperationRegistry, hasAllCapabilities };
+export { createOperationRegistry };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export type ArgSpec =\n  | { readonly kind: 'typeId'; readonly type: string }\n  | { readonly kind: 'param' }\n  | { readonly kind: 'literal' };\n\nexport type ReturnSpec =\n  | { readonly kind: 'typeId'; readonly type: string }\n  | { readonly kind: 'builtin'; readonly type: 'number' | 'boolean' | 'string' };\n\nexport interface OperationSignature {\n  readonly forTypeId: string;\n  readonly method: string;\n  readonly args: ReadonlyArray<ArgSpec>;\n  readonly returns: ReturnSpec;\n  readonly capabilities?: ReadonlyArray<string>;\n}\n\nexport interface OperationRegistry<T extends OperationSignature = OperationSignature> {\n  register(op: T): void;\n  byType(typeId: string): ReadonlyArray<T>;\n}\n\nclass OperationRegistryImpl<T extends OperationSignature = OperationSignature>\n  implements OperationRegistry<T>\n{\n  private readonly operations = new Map<string, T[]>();\n\n  register(op: T): void {\n    const existing = this.operations.get(op.forTypeId) ?? [];\n    const duplicate = existing.find((existingOp) => existingOp.method === op.method);\n    if (duplicate) {\n      throw new Error(\n        `Operation method \"${op.method}\" already registered for typeId \"${op.forTypeId}\"`,\n      );\n    }\n    existing.push(op);\n    this.operations.set(op.forTypeId, existing);\n  }\n\n  byType(typeId: string): ReadonlyArray<T> {\n    return this.operations.get(typeId) ?? [];\n  }\n}\n\nexport function createOperationRegistry<\n  T extends OperationSignature = OperationSignature,\n>(): OperationRegistry<T> {\n  return new OperationRegistryImpl<T>();\n}\n\nexport function hasAllCapabilities(\n  capabilities: ReadonlyArray<string>,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): boolean {\n  if (!contractCapabilities) {\n    return false;\n  }\n\n  return capabilities.every((cap) => {\n    const [namespace, ...rest] = cap.split('.');\n    const key = rest.join('.');\n    const namespaceCaps = namespace ? contractCapabilities[namespace] : undefined;\n    return namespaceCaps?.[key] === true;\n  });\n}\n"],"mappings":";AAsBA,IAAM,wBAAN,MAEA;CACE,AAAiB,6BAAa,IAAI,KAAkB;CAEpD,SAAS,IAAa;EACpB,MAAM,WAAW,KAAK,WAAW,IAAI,GAAG,UAAU,IAAI,EAAE;AAExD,MADkB,SAAS,MAAM,eAAe,WAAW,WAAW,GAAG,OAAO,CAE9E,OAAM,IAAI,MACR,qBAAqB,GAAG,OAAO,mCAAmC,GAAG,UAAU,GAChF;AAEH,WAAS,KAAK,GAAG;AACjB,OAAK,WAAW,IAAI,GAAG,WAAW,SAAS;;CAG7C,OAAO,QAAkC;AACvC,SAAO,KAAK,WAAW,IAAI,OAAO,IAAI,EAAE;;;AAI5C,SAAgB,0BAEU;AACxB,QAAO,IAAI,uBAA0B;;AAGvC,SAAgB,mBACd,cACA,sBACS;AACT,KAAI,CAAC,qBACH,QAAO;AAGT,QAAO,aAAa,OAAO,QAAQ;EACjC,MAAM,CAAC,WAAW,GAAG,QAAQ,IAAI,MAAM,IAAI;EAC3C,MAAM,MAAM,KAAK,KAAK,IAAI;AAE1B,UADsB,YAAY,qBAAqB,aAAa,UAC7C,SAAS;GAChC"}
+{"version":3,"file":"index.mjs","names":["operations: Record<string, T>"],"sources":["../src/index.ts"],"sourcesContent":["export interface ParamSpec {\n  readonly codecId: string;\n  readonly nullable: boolean;\n}\n\nexport interface OperationEntry {\n  readonly args: readonly ParamSpec[];\n  readonly returns: ParamSpec;\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      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":";AAmBA,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;GAE3E,MAAM,EAAE,QAAQ,SAAS,GAAG,UAAU;AAGtC,cAAW,WAAW,UAAU;;EAElC,UAAU;AACR,UAAO,OAAO,OAAO,EAAE,GAAG,YAAY,CAAC;;EAE1C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/operations",
-  "version": "0.3.0-dev.145",
+  "version": "0.3.0-dev.146",
   "type": "module",
   "sideEffects": false,
   "description": "Target-neutral operation registry and capability helpers for Prisma Next",
@@ -10,8 +10,8 @@
     "typescript": "5.9.3",
     "vitest": "4.0.17",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
     "dist",

package/src/index.ts

@@ -1,65 +1,39 @@
-export type ArgSpec =
-  | { readonly kind: 'typeId'; readonly type: string }
-  | { readonly kind: 'param' }
-  | { readonly kind: 'literal' };
-
-export type ReturnSpec =
-  | { readonly kind: 'typeId'; readonly type: string }
-  | { readonly kind: 'builtin'; readonly type: 'number' | 'boolean' | 'string' };
-
-export interface OperationSignature {
-  readonly forTypeId: string;
-  readonly method: string;
-  readonly args: ReadonlyArray<ArgSpec>;
-  readonly returns: ReturnSpec;
-  readonly capabilities?: ReadonlyArray<string>;
+export interface ParamSpec {
+  readonly codecId: string;
+  readonly nullable: boolean;
 }
 
-export interface OperationRegistry<T extends OperationSignature = OperationSignature> {
-  register(op: T): void;
-  byType(typeId: string): ReadonlyArray<T>;
+export interface OperationEntry {
+  readonly args: readonly ParamSpec[];
+  readonly returns: ParamSpec;
 }
 
-class OperationRegistryImpl<T extends OperationSignature = OperationSignature>
-  implements OperationRegistry<T>
-{
-  private readonly operations = new Map<string, T[]>();
-
-  register(op: T): void {
-    const existing = this.operations.get(op.forTypeId) ?? [];
-    const duplicate = existing.find((existingOp) => existingOp.method === op.method);
-    if (duplicate) {
-      throw new Error(
-        `Operation method "${op.method}" already registered for typeId "${op.forTypeId}"`,
-      );
-    }
-    existing.push(op);
-    this.operations.set(op.forTypeId, existing);
-  }
+export type OperationDescriptor<T extends OperationEntry = OperationEntry> = T & {
+  readonly method: string;
+};
 
-  byType(typeId: string): ReadonlyArray<T> {
-    return this.operations.get(typeId) ?? [];
-  }
+export interface OperationRegistry<T extends OperationEntry = OperationEntry> {
+  register(descriptor: OperationDescriptor<T>): void;
+  entries(): Readonly<Record<string, T>>;
 }
 
 export function createOperationRegistry<
-  T extends OperationSignature = OperationSignature,
+  T extends OperationEntry = OperationEntry,
 >(): OperationRegistry<T> {
-  return new OperationRegistryImpl<T>();
-}
-
-export function hasAllCapabilities(
-  capabilities: ReadonlyArray<string>,
-  contractCapabilities?: Record<string, Record<string, boolean>>,
-): boolean {
-  if (!contractCapabilities) {
-    return false;
-  }
-
-  return capabilities.every((cap) => {
-    const [namespace, ...rest] = cap.split('.');
-    const key = rest.join('.');
-    const namespaceCaps = namespace ? contractCapabilities[namespace] : undefined;
-    return namespaceCaps?.[key] === true;
-  });
+  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`);
+      }
+      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;
+    },
+    entries() {
+      return Object.freeze({ ...operations });
+    },
+  };
 }