@prisma-next/contract 0.1.0-pr.64.2 → 0.1.0-pr.65.1

package/README.md

@@ -104,7 +104,7 @@ const sqlFamily: FamilyDescriptor<'sql'> = {
   kind: 'family',
   id: 'sql',
   familyId: 'sql',
-  manifest: { /* ... */ },
+  version: '1.0.0',
 };
 
 // Use TargetDescriptor for target components
@@ -113,7 +113,9 @@ const postgresTarget: TargetDescriptor<'sql', 'postgres'> = {
   id: 'postgres',
   familyId: 'sql',
   targetId: 'postgres',
-  manifest: { /* ... */ },
+  version: '15.0.0',
+  targets: { postgres: { minVersion: '12' } },
+  capabilities: { postgres: { returning: true } },
 };
 
 // Identity instance bases are extended by plane-specific instances

package/dist/exports/framework-components.d.ts

@@ -1,7 +1,38 @@
-import { E as ExtensionPackManifest } from './pack-manifest-types-BYh8H2fb.js';
+import { TypesImportSpec, OperationManifest } from './types.js';
 import '@prisma-next/operations';
 import './ir.js';
 
+/**
+ * Declarative fields that describe component metadata.
+ * These fields are owned directly by descriptors (not nested under a manifest).
+ */
+interface ComponentDeclarativeFields {
+    /** Component version (semver) */
+    readonly version: string;
+    /** Target metadata - which targets this component supports */
+    readonly targets?: Record<string, {
+        readonly minVersion?: string;
+    }>;
+    /** Capabilities this component provides */
+    readonly capabilities?: Record<string, unknown>;
+    /** Type imports for contract.d.ts generation */
+    readonly types?: {
+        readonly codecTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly operationTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly storage?: ReadonlyArray<{
+            readonly typeId: string;
+            readonly familyId: string;
+            readonly targetId: string;
+            readonly nativeType?: string;
+        }>;
+    };
+    /** Operation manifests for building operation registries */
+    readonly operations?: ReadonlyArray<OperationManifest>;
+}
 /**
  * Base descriptor for any framework component.
  *
@@ -18,16 +49,14 @@ import './ir.js';
  * // All descriptors have these properties
  * descriptor.kind     // The Kind type parameter (e.g., 'family', 'target', or custom kinds)
  * descriptor.id       // Unique string identifier (e.g., 'sql', 'postgres')
- * descriptor.manifest // Package metadata (version, capabilities, types, etc.)
+ * descriptor.version  // Component version (semver)
  * ```
  */
-interface ComponentDescriptor<Kind extends string> {
+interface ComponentDescriptor<Kind extends string> extends ComponentDeclarativeFields {
     /** Discriminator identifying the component type */
     readonly kind: Kind;
     /** Unique identifier for this component (e.g., 'sql', 'postgres', 'pgvector') */
     readonly id: string;
-    /** Package manifest containing version, capabilities, type imports, and operations */
-    readonly manifest: ExtensionPackManifest;
 }
 /**
  * Descriptor for a family component.

package/dist/exports/pack-manifest-types.d.ts

@@ -1,3 +1,3 @@
-export { A as ArgSpecManifest, k as ExtensionPack, E as ExtensionPackManifest, L as LoweringSpecManifest, O as OperationManifest, l as ReturnSpecManifest } from './pack-manifest-types-BYh8H2fb.js';
+export { A as ArgSpecManifest, E as ExtensionPack, a as ExtensionPackManifest, L as LoweringSpecManifest, OperationManifest, R as ReturnSpecManifest } from './types.js';
 import '@prisma-next/operations';
 import './ir.js';

package/dist/exports/types.d.ts

@@ -1,3 +1,251 @@
-export { C as ContractBase, a as ContractMarkerRecord, D as DocCollection, b as DocIndex, c as DocumentContract, d as DocumentStorage, e as ExecutionPlan, f as Expr, F as FieldType, P as ParamDescriptor, g as PlanMeta, h as PlanRefs, R as ResultType, S as Source, T as TargetFamilyHook, i as TypesImportSpec, V as ValidationContext, j as isDocumentContract } from './pack-manifest-types-BYh8H2fb.js';
-import '@prisma-next/operations';
-import './ir.js';
+import { OperationRegistry } from '@prisma-next/operations';
+import { ContractIR } from './ir.js';
+
+interface ContractBase {
+    readonly schemaVersion: string;
+    readonly target: string;
+    readonly targetFamily: string;
+    readonly coreHash: string;
+    readonly profileHash?: string;
+    readonly capabilities?: Record<string, Record<string, boolean>>;
+    readonly extensions?: Record<string, unknown>;
+    readonly meta?: Record<string, unknown>;
+    readonly sources?: Record<string, Source>;
+}
+interface FieldType {
+    readonly type: string;
+    readonly nullable: boolean;
+    readonly items?: FieldType;
+    readonly properties?: Record<string, FieldType>;
+}
+interface Source {
+    readonly readOnly: boolean;
+    readonly projection: Record<string, FieldType>;
+    readonly origin?: Record<string, unknown>;
+    readonly capabilities?: Record<string, boolean>;
+}
+interface DocIndex {
+    readonly name: string;
+    readonly keys: Record<string, 'asc' | 'desc'>;
+    readonly unique?: boolean;
+    readonly where?: Expr;
+}
+type Expr = {
+    readonly kind: 'eq';
+    readonly path: ReadonlyArray<string>;
+    readonly value: unknown;
+} | {
+    readonly kind: 'exists';
+    readonly path: ReadonlyArray<string>;
+};
+interface DocCollection {
+    readonly name: string;
+    readonly id?: {
+        readonly strategy: 'auto' | 'client' | 'uuid' | 'cuid' | 'objectId';
+    };
+    readonly fields: Record<string, FieldType>;
+    readonly indexes?: ReadonlyArray<DocIndex>;
+    readonly readOnly?: boolean;
+}
+interface DocumentStorage {
+    readonly document: {
+        readonly collections: Record<string, DocCollection>;
+    };
+}
+interface DocumentContract extends ContractBase {
+    readonly targetFamily: string;
+    readonly storage: DocumentStorage;
+}
+interface ParamDescriptor {
+    readonly index?: number;
+    readonly name?: string;
+    readonly codecId?: string;
+    readonly nativeType?: string;
+    readonly nullable?: boolean;
+    readonly source: 'dsl' | 'raw';
+    readonly refs?: {
+        table: string;
+        column: string;
+    };
+}
+interface PlanRefs {
+    readonly tables?: readonly string[];
+    readonly columns?: ReadonlyArray<{
+        table: string;
+        column: string;
+    }>;
+    readonly indexes?: ReadonlyArray<{
+        readonly table: string;
+        readonly columns: ReadonlyArray<string>;
+        readonly name?: string;
+    }>;
+}
+interface PlanMeta {
+    readonly target: string;
+    readonly targetFamily?: string;
+    readonly coreHash: string;
+    readonly profileHash?: string;
+    readonly lane: string;
+    readonly annotations?: {
+        codecs?: Record<string, string>;
+        [key: string]: unknown;
+    };
+    readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;
+    readonly refs?: PlanRefs;
+    readonly projection?: Record<string, string> | ReadonlyArray<string>;
+    /**
+     * Optional mapping of projection alias → column type ID (fully qualified ns/name@version).
+     * Used for codec resolution when AST+refs don't provide enough type info.
+     */
+    readonly projectionTypes?: Record<string, string>;
+}
+/**
+ * Canonical execution plan shape used by runtimes.
+ *
+ * - Row is the inferred result row type (TypeScript-only).
+ * - Ast is the optional, family-specific AST type (e.g. SQL QueryAst).
+ *
+ * The payload executed by the runtime is represented by the sql + params pair
+ * for now; future families can specialize this via Ast or additional metadata.
+ */
+interface ExecutionPlan<Row = unknown, Ast = unknown> {
+    readonly sql: string;
+    readonly params: readonly unknown[];
+    readonly ast?: Ast;
+    readonly meta: PlanMeta;
+    /**
+     * Phantom property to carry the Row generic for type-level utilities.
+     * Not set at runtime; used only for ResultType extraction.
+     */
+    readonly _row?: Row;
+}
+/**
+ * Utility type to extract the Row type from an ExecutionPlan.
+ * Example: `type Row = ResultType<typeof plan>`
+ *
+ * Works with both ExecutionPlan and SqlQueryPlan (SQL query plans before lowering).
+ * SqlQueryPlan includes a phantom `_Row` property to preserve the generic parameter
+ * for type extraction.
+ */
+type ResultType<P> = P extends ExecutionPlan<infer R, unknown> ? R : P extends {
+    readonly _Row?: infer R;
+} ? R : never;
+/**
+ * Type guard to check if a contract is a Document contract
+ */
+declare function isDocumentContract(contract: unknown): contract is DocumentContract;
+/**
+ * Contract marker record stored in the database.
+ * Represents the current contract identity for a database.
+ */
+interface ContractMarkerRecord {
+    readonly coreHash: string;
+    readonly profileHash: string;
+    readonly contractJson: unknown | null;
+    readonly canonicalVersion: number | null;
+    readonly updatedAt: Date;
+    readonly appTag: string | null;
+    readonly meta: Record<string, unknown>;
+}
+/**
+ * Specifies how to import TypeScript types from a package.
+ * Used in extension pack manifests to declare codec and operation type imports.
+ */
+interface TypesImportSpec {
+    readonly package: string;
+    readonly named: string;
+    readonly alias: string;
+}
+/**
+ * Validation context passed to TargetFamilyHook.validateTypes().
+ * Contains pre-assembled operation registry, type imports, and extension IDs.
+ */
+interface ValidationContext {
+    readonly operationRegistry?: OperationRegistry;
+    readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
+    readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
+    readonly extensionIds?: ReadonlyArray<string>;
+}
+/**
+ * SPI interface for target family hooks that extend emission behavior.
+ * Implemented by family-specific emitter hooks (e.g., SQL family).
+ */
+interface TargetFamilyHook {
+    readonly id: string;
+    /**
+     * Validates that all type IDs in the contract come from referenced extensions.
+     * @param ir - Contract IR to validate
+     * @param ctx - Validation context with operation registry and extension IDs
+     */
+    validateTypes(ir: ContractIR, ctx: ValidationContext): void;
+    /**
+     * Validates family-specific contract structure.
+     * @param ir - Contract IR to validate
+     */
+    validateStructure(ir: ContractIR): void;
+    /**
+     * Generates contract.d.ts file content.
+     * @param ir - Contract IR
+     * @param codecTypeImports - Array of codec type import specs
+     * @param operationTypeImports - Array of operation type import specs
+     * @returns Generated TypeScript type definitions as string
+     */
+    generateContractTypes(ir: ContractIR, codecTypeImports: ReadonlyArray<TypesImportSpec>, operationTypeImports: ReadonlyArray<TypesImportSpec>): string;
+}
+type ArgSpecManifest = {
+    readonly kind: 'typeId';
+    readonly type: string;
+} | {
+    readonly kind: 'param';
+} | {
+    readonly kind: 'literal';
+};
+type ReturnSpecManifest = {
+    readonly kind: 'typeId';
+    readonly type: string;
+} | {
+    readonly kind: 'builtin';
+    readonly type: 'number' | 'boolean' | 'string';
+};
+interface LoweringSpecManifest {
+    readonly targetFamily: 'sql';
+    readonly strategy: 'infix' | 'function';
+    readonly template: string;
+}
+interface OperationManifest {
+    readonly for: string;
+    readonly method: string;
+    readonly args: ReadonlyArray<ArgSpecManifest>;
+    readonly returns: ReturnSpecManifest;
+    readonly lowering: LoweringSpecManifest;
+    readonly capabilities?: ReadonlyArray<string>;
+}
+interface ExtensionPackManifest {
+    readonly id: string;
+    readonly version: string;
+    readonly targets?: Record<string, {
+        readonly minVersion?: string;
+    }>;
+    readonly capabilities?: Record<string, unknown>;
+    readonly types?: {
+        readonly codecTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly operationTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly storage?: readonly {
+            readonly typeId: string;
+            readonly familyId: string;
+            readonly targetId: string;
+            readonly nativeType?: string;
+        }[];
+    };
+    readonly operations?: ReadonlyArray<OperationManifest>;
+}
+interface ExtensionPack {
+    readonly manifest: ExtensionPackManifest;
+    readonly path: string;
+}
+
+export { type ArgSpecManifest as A, type ContractBase, type ContractMarkerRecord, type DocCollection, type DocIndex, type DocumentContract, type DocumentStorage, type ExtensionPack as E, type ExecutionPlan, type Expr, type FieldType, type LoweringSpecManifest as L, type OperationManifest, type ParamDescriptor, type PlanMeta, type PlanRefs, type ReturnSpecManifest as R, type ResultType, type Source, type TargetFamilyHook, type TypesImportSpec, type ValidationContext, type ExtensionPackManifest as a, isDocumentContract };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.1.0-pr.64.2",
+  "version": "0.1.0-pr.65.1",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/operations": "0.1.0-pr.64.2"
+    "@prisma-next/operations": "0.1.0-pr.65.1"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.0.0",
+    "@vitest/coverage-v8": "^2.1.1",
     "tsup": "^8.3.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.16",

package/dist/exports/pack-manifest-types-BYh8H2fb.d.ts

@@ -1,251 +0,0 @@
-import { OperationRegistry } from '@prisma-next/operations';
-import { ContractIR } from './ir.js';
-
-interface ContractBase {
-    readonly schemaVersion: string;
-    readonly target: string;
-    readonly targetFamily: string;
-    readonly coreHash: string;
-    readonly profileHash?: string;
-    readonly capabilities?: Record<string, Record<string, boolean>>;
-    readonly extensions?: Record<string, unknown>;
-    readonly meta?: Record<string, unknown>;
-    readonly sources?: Record<string, Source>;
-}
-interface FieldType {
-    readonly type: string;
-    readonly nullable: boolean;
-    readonly items?: FieldType;
-    readonly properties?: Record<string, FieldType>;
-}
-interface Source {
-    readonly readOnly: boolean;
-    readonly projection: Record<string, FieldType>;
-    readonly origin?: Record<string, unknown>;
-    readonly capabilities?: Record<string, boolean>;
-}
-interface DocIndex {
-    readonly name: string;
-    readonly keys: Record<string, 'asc' | 'desc'>;
-    readonly unique?: boolean;
-    readonly where?: Expr;
-}
-type Expr = {
-    readonly kind: 'eq';
-    readonly path: ReadonlyArray<string>;
-    readonly value: unknown;
-} | {
-    readonly kind: 'exists';
-    readonly path: ReadonlyArray<string>;
-};
-interface DocCollection {
-    readonly name: string;
-    readonly id?: {
-        readonly strategy: 'auto' | 'client' | 'uuid' | 'cuid' | 'objectId';
-    };
-    readonly fields: Record<string, FieldType>;
-    readonly indexes?: ReadonlyArray<DocIndex>;
-    readonly readOnly?: boolean;
-}
-interface DocumentStorage {
-    readonly document: {
-        readonly collections: Record<string, DocCollection>;
-    };
-}
-interface DocumentContract extends ContractBase {
-    readonly targetFamily: string;
-    readonly storage: DocumentStorage;
-}
-interface ParamDescriptor {
-    readonly index?: number;
-    readonly name?: string;
-    readonly codecId?: string;
-    readonly nativeType?: string;
-    readonly nullable?: boolean;
-    readonly source: 'dsl' | 'raw';
-    readonly refs?: {
-        table: string;
-        column: string;
-    };
-}
-interface PlanRefs {
-    readonly tables?: readonly string[];
-    readonly columns?: ReadonlyArray<{
-        table: string;
-        column: string;
-    }>;
-    readonly indexes?: ReadonlyArray<{
-        readonly table: string;
-        readonly columns: ReadonlyArray<string>;
-        readonly name?: string;
-    }>;
-}
-interface PlanMeta {
-    readonly target: string;
-    readonly targetFamily?: string;
-    readonly coreHash: string;
-    readonly profileHash?: string;
-    readonly lane: string;
-    readonly annotations?: {
-        codecs?: Record<string, string>;
-        [key: string]: unknown;
-    };
-    readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;
-    readonly refs?: PlanRefs;
-    readonly projection?: Record<string, string> | ReadonlyArray<string>;
-    /**
-     * Optional mapping of projection alias → column type ID (fully qualified ns/name@version).
-     * Used for codec resolution when AST+refs don't provide enough type info.
-     */
-    readonly projectionTypes?: Record<string, string>;
-}
-/**
- * Canonical execution plan shape used by runtimes.
- *
- * - Row is the inferred result row type (TypeScript-only).
- * - Ast is the optional, family-specific AST type (e.g. SQL QueryAst).
- *
- * The payload executed by the runtime is represented by the sql + params pair
- * for now; future families can specialize this via Ast or additional metadata.
- */
-interface ExecutionPlan<Row = unknown, Ast = unknown> {
-    readonly sql: string;
-    readonly params: readonly unknown[];
-    readonly ast?: Ast;
-    readonly meta: PlanMeta;
-    /**
-     * Phantom property to carry the Row generic for type-level utilities.
-     * Not set at runtime; used only for ResultType extraction.
-     */
-    readonly _row?: Row;
-}
-/**
- * Utility type to extract the Row type from an ExecutionPlan.
- * Example: `type Row = ResultType<typeof plan>`
- *
- * Works with both ExecutionPlan and SqlQueryPlan (SQL query plans before lowering).
- * SqlQueryPlan includes a phantom `_Row` property to preserve the generic parameter
- * for type extraction.
- */
-type ResultType<P> = P extends ExecutionPlan<infer R, unknown> ? R : P extends {
-    readonly _Row?: infer R;
-} ? R : never;
-/**
- * Type guard to check if a contract is a Document contract
- */
-declare function isDocumentContract(contract: unknown): contract is DocumentContract;
-/**
- * Contract marker record stored in the database.
- * Represents the current contract identity for a database.
- */
-interface ContractMarkerRecord {
-    readonly coreHash: string;
-    readonly profileHash: string;
-    readonly contractJson: unknown | null;
-    readonly canonicalVersion: number | null;
-    readonly updatedAt: Date;
-    readonly appTag: string | null;
-    readonly meta: Record<string, unknown>;
-}
-/**
- * Specifies how to import TypeScript types from a package.
- * Used in extension pack manifests to declare codec and operation type imports.
- */
-interface TypesImportSpec {
-    readonly package: string;
-    readonly named: string;
-    readonly alias: string;
-}
-/**
- * Validation context passed to TargetFamilyHook.validateTypes().
- * Contains pre-assembled operation registry, type imports, and extension IDs.
- */
-interface ValidationContext {
-    readonly operationRegistry?: OperationRegistry;
-    readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
-    readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
-    readonly extensionIds?: ReadonlyArray<string>;
-}
-/**
- * SPI interface for target family hooks that extend emission behavior.
- * Implemented by family-specific emitter hooks (e.g., SQL family).
- */
-interface TargetFamilyHook {
-    readonly id: string;
-    /**
-     * Validates that all type IDs in the contract come from referenced extensions.
-     * @param ir - Contract IR to validate
-     * @param ctx - Validation context with operation registry and extension IDs
-     */
-    validateTypes(ir: ContractIR, ctx: ValidationContext): void;
-    /**
-     * Validates family-specific contract structure.
-     * @param ir - Contract IR to validate
-     */
-    validateStructure(ir: ContractIR): void;
-    /**
-     * Generates contract.d.ts file content.
-     * @param ir - Contract IR
-     * @param codecTypeImports - Array of codec type import specs
-     * @param operationTypeImports - Array of operation type import specs
-     * @returns Generated TypeScript type definitions as string
-     */
-    generateContractTypes(ir: ContractIR, codecTypeImports: ReadonlyArray<TypesImportSpec>, operationTypeImports: ReadonlyArray<TypesImportSpec>): string;
-}
-type ArgSpecManifest = {
-    readonly kind: 'typeId';
-    readonly type: string;
-} | {
-    readonly kind: 'param';
-} | {
-    readonly kind: 'literal';
-};
-type ReturnSpecManifest = {
-    readonly kind: 'typeId';
-    readonly type: string;
-} | {
-    readonly kind: 'builtin';
-    readonly type: 'number' | 'boolean' | 'string';
-};
-interface LoweringSpecManifest {
-    readonly targetFamily: 'sql';
-    readonly strategy: 'infix' | 'function';
-    readonly template: string;
-}
-interface OperationManifest {
-    readonly for: string;
-    readonly method: string;
-    readonly args: ReadonlyArray<ArgSpecManifest>;
-    readonly returns: ReturnSpecManifest;
-    readonly lowering: LoweringSpecManifest;
-    readonly capabilities?: ReadonlyArray<string>;
-}
-interface ExtensionPackManifest {
-    readonly id: string;
-    readonly version: string;
-    readonly targets?: Record<string, {
-        readonly minVersion?: string;
-    }>;
-    readonly capabilities?: Record<string, unknown>;
-    readonly types?: {
-        readonly codecTypes?: {
-            readonly import: TypesImportSpec;
-        };
-        readonly operationTypes?: {
-            readonly import: TypesImportSpec;
-        };
-        readonly storage?: readonly {
-            readonly typeId: string;
-            readonly familyId: string;
-            readonly targetId: string;
-            readonly nativeType?: string;
-        }[];
-    };
-    readonly operations?: ReadonlyArray<OperationManifest>;
-}
-interface ExtensionPack {
-    readonly manifest: ExtensionPackManifest;
-    readonly path: string;
-}
-
-export { type ArgSpecManifest as A, type ContractBase as C, type DocCollection as D, type ExtensionPackManifest as E, type FieldType as F, type LoweringSpecManifest as L, type OperationManifest as O, type ParamDescriptor as P, type ResultType as R, type Source as S, type TargetFamilyHook as T, type ValidationContext as V, type ContractMarkerRecord as a, type DocIndex as b, type DocumentContract as c, type DocumentStorage as d, type ExecutionPlan as e, type Expr as f, type PlanMeta as g, type PlanRefs as h, type TypesImportSpec as i, isDocumentContract as j, type ExtensionPack as k, type ReturnSpecManifest as l };