@prisma-next/operations 0.0.1

package/README.md

@@ -0,0 +1,102 @@
+# @prisma-next/operations
+
+Target-neutral operation registry and capability helpers 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.
+
+## 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
+
+## Dependencies
+
+- **Depends on**: `@prisma-next/plan` (for plan error types)
+- **Note**: This package does not depend on `@prisma-next/contract` despite being in the same layer. `OperationRegistry` is used by contract types, but operations package itself has no contract dependencies.
+- **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)
+
+## Architecture
+
+```mermaid
+flowchart TD
+    subgraph "Core Ring"
+        OPS[@prisma-next/operations]
+    end
+
+    subgraph "Targets Ring"
+        SQL_OPS[@prisma-next/sql-operations]
+    end
+
+    subgraph "Lanes Ring"
+        REL_CORE[@prisma-next/sql-relational-core]
+    end
+
+    subgraph "Runtime Ring"
+        RT[@prisma-next/runtime]
+    end
+
+    OPS --> SQL_OPS
+    OPS --> REL_CORE
+    OPS --> RT
+```
+
+## Usage
+
+### Creating an Operation Registry
+
+```typescript
+import { createOperationRegistry, type OperationSignature } from '@prisma-next/operations';
+
+const registry = createOperationRegistry();
+
+const signature: OperationSignature = {
+  forTypeId: 'pg/vector@1',
+  method: 'cosineDistance',
+  args: [{ kind: 'typeId', type: 'pg/vector@1' }],
+  returns: { kind: 'builtin', type: 'number' },
+};
+
+registry.register(signature);
+const operations = registry.byType('pg/vector@1');
+```
+
+### Checking Capabilities
+
+```typescript
+import { hasAllCapabilities } from '@prisma-next/operations';
+
+const contractCapabilities = {
+  pgvector: {
+    'index.ivfflat': true,
+  },
+};
+
+const hasCapability = hasAllCapabilities(
+  ['pgvector.index.ivfflat'],
+  contractCapabilities,
+);
+```
+
+## Package Location
+
+This package is part of the **framework domain**, **core layer**, **shared plane**:
+- **Domain**: framework (target-agnostic)
+- **Layer**: core
+- **Plane**: shared
+- **Path**: `packages/framework/core-operations`
+
+## Related Documentation
+
+- [Package Layering](../../../../docs/architecture docs/Package-Layering.md)
+- [ADR 140 - Package Layering & Target-Family Namespacing](../../../../docs/architecture docs/adrs/ADR 140 - Package Layering & Target-Family Namespacing.md)

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+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 OperationRegistry {
+    register(op: OperationSignature): void;
+    byType(typeId: string): ReadonlyArray<OperationSignature>;
+}
+declare function createOperationRegistry(): OperationRegistry;
+declare function hasAllCapabilities(capabilities: ReadonlyArray<string>, contractCapabilities?: Record<string, Record<string, boolean>>): boolean;
+
+export { type ArgSpec, type OperationRegistry, type OperationSignature, type ReturnSpec, createOperationRegistry, hasAllCapabilities };

package/dist/index.js

@@ -0,0 +1,37 @@
+// src/index.ts
+var OperationRegistryImpl = class {
+  operations = /* @__PURE__ */ new Map();
+  register(op) {
+    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);
+  }
+  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(".");
+    const namespaceCaps = namespace ? contractCapabilities[namespace] : void 0;
+    return namespaceCaps?.[key] === true;
+  });
+}
+export {
+  createOperationRegistry,
+  hasAllCapabilities
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"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 {\n  register(op: OperationSignature): void;\n  byType(typeId: string): ReadonlyArray<OperationSignature>;\n}\n\nclass OperationRegistryImpl implements OperationRegistry {\n  private readonly operations = new Map<string, OperationSignature[]>();\n\n  register(op: OperationSignature): 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<OperationSignature> {\n    return this.operations.get(typeId) ?? [];\n  }\n}\n\nexport function createOperationRegistry(): OperationRegistry {\n  return new OperationRegistryImpl();\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,MAAyD;AAAA,EACtC,aAAa,oBAAI,IAAkC;AAAA,EAEpE,SAAS,IAA8B;AACrC,UAAM,WAAW,KAAK,WAAW,IAAI,GAAG,SAAS,KAAK,CAAC;AACvD,UAAM,YAAY,SAAS,KAAK,CAAC,eAAe,WAAW,WAAW,GAAG,MAAM;AAC/E,QAAI,WAAW;AACb,YAAM,IAAI;AAAA,QACR,qBAAqB,GAAG,MAAM,oCAAoC,GAAG,SAAS;AAAA,MAChF;AAAA,IACF;AACA,aAAS,KAAK,EAAE;AAChB,SAAK,WAAW,IAAI,GAAG,WAAW,QAAQ;AAAA,EAC5C;AAAA,EAEA,OAAO,QAAmD;AACxD,WAAO,KAAK,WAAW,IAAI,MAAM,KAAK,CAAC;AAAA,EACzC;AACF;AAEO,SAAS,0BAA6C;AAC3D,SAAO,IAAI,sBAAsB;AACnC;AAEO,SAAS,mBACd,cACA,sBACS;AACT,MAAI,CAAC,sBAAsB;AACzB,WAAO;AAAA,EACT;AAEA,SAAO,aAAa,MAAM,CAAC,QAAQ;AACjC,UAAM,CAAC,WAAW,GAAG,IAAI,IAAI,IAAI,MAAM,GAAG;AAC1C,UAAM,MAAM,KAAK,KAAK,GAAG;AACzB,UAAM,gBAAgB,YAAY,qBAAqB,SAAS,IAAI;AACpE,WAAO,gBAAgB,GAAG,MAAM;AAAA,EAClC,CAAC;AACH;","names":[]}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@prisma-next/operations",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "description": "Target-neutral operation registry and capability helpers for Prisma Next",
+  "dependencies": {
+    "@prisma-next/plan": "0.0.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.1",
+    "@prisma-next/test-utils": "0.0.1"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage --passWithNoTests",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "biome check . --config-path ../../../biome.json --error-on-warnings",
+    "clean": "node ../../../scripts/clean.mjs"
+  }
+}