@prisma-next/sql-relational-core 0.0.1

package/dist/query-lane-context-BhOMmb_K.d.ts

@@ -0,0 +1,158 @@
+import { OperationRegistry } from '@prisma-next/operations';
+import { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import { O } from 'ts-toolbelt';
+
+/**
+ * Codec metadata for database-specific type information.
+ * Used for schema introspection and verification.
+ */
+interface CodecMeta {
+    readonly db?: {
+        readonly sql?: {
+            readonly postgres?: {
+                readonly nativeType: string;
+            };
+        };
+    };
+}
+/**
+ * Codec interface for encoding/decoding values between wire format and JavaScript types.
+ *
+ * Codecs are pure, synchronous functions with no side effects or IO.
+ * They provide deterministic conversion between database wire types and JS values.
+ */
+interface Codec<Id extends string = string, TWire = unknown, TJs = unknown> {
+    /**
+     * Namespaced codec identifier in format 'namespace/name@version'
+     * Examples: 'pg/text@1', 'pg/uuid@1', 'pg/timestamptz@1'
+     */
+    readonly id: Id;
+    /**
+     * Contract scalar type IDs that this codec can handle.
+     * Examples: ['text'], ['int4', 'float8'], ['timestamp', 'timestamptz']
+     */
+    readonly targetTypes: readonly string[];
+    /**
+     * Optional metadata for database-specific type information.
+     * Used for schema introspection and verification.
+     */
+    readonly meta?: CodecMeta;
+    /**
+     * Decode a wire value (from database) to JavaScript type.
+     * Must be synchronous and pure (no side effects).
+     */
+    decode(wire: TWire): TJs;
+    /**
+     * Encode a JavaScript value to wire format (for database).
+     * Optional - if not provided, values pass through unchanged.
+     * Must be synchronous and pure (no side effects).
+     */
+    encode?(value: TJs): TWire;
+}
+/**
+ * Registry interface for codecs organized by ID and by contract scalar type.
+ *
+ * The registry allows looking up codecs by their namespaced ID or by the
+ * contract scalar types they handle. Multiple codecs may handle the same
+ * scalar type; ordering in byScalar reflects preference (adapter first,
+ * then packs, then app overrides).
+ */
+interface CodecRegistry {
+    get(id: string): Codec<string> | undefined;
+    has(id: string): boolean;
+    getByScalar(scalar: string): readonly Codec<string>[];
+    getDefaultCodec(scalar: string): Codec<string> | undefined;
+    register(codec: Codec<string>): void;
+    [Symbol.iterator](): Iterator<Codec<string>>;
+    values(): IterableIterator<Codec<string>>;
+}
+/**
+ * Codec factory - creates a codec with typeId and encode/decode functions.
+ */
+declare function codec<Id extends string, TWire, TJs>(config: {
+    typeId: Id;
+    targetTypes: readonly string[];
+    encode: (value: TJs) => TWire;
+    decode: (wire: TWire) => TJs;
+    meta?: CodecMeta;
+}): Codec<Id, TWire, TJs>;
+/**
+ * Type helpers to extract codec types.
+ */
+type CodecId<T> = T extends Codec<infer Id, unknown, unknown> ? Id : T extends {
+    readonly id: infer Id;
+} ? Id : never;
+type CodecInput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;
+type CodecOutput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;
+/**
+ * Type helper to extract codec types from builder instance.
+ */
+type ExtractCodecTypes<ScalarNames extends {
+    readonly [K in keyof ScalarNames]: Codec<string>;
+} = Record<never, never>> = {
+    readonly [K in keyof ScalarNames as ScalarNames[K] extends Codec<infer Id, unknown, unknown> ? Id : never]: {
+        readonly input: CodecInput<ScalarNames[K]>;
+        readonly output: CodecOutput<ScalarNames[K]>;
+    };
+};
+/**
+ * Type helper to extract data type IDs from builder instance.
+ * Uses ExtractCodecTypes which preserves literal types as keys.
+ * Since ExtractCodecTypes<Record<K, ScalarNames[K]>> has exactly one key (the Id),
+ * we extract it by creating a mapped type that uses the Id as both key and value,
+ * then extract the value type. This preserves literal types.
+ */
+type ExtractDataTypes<ScalarNames extends {
+    readonly [K in keyof ScalarNames]: Codec<string>;
+}> = {
+    readonly [K in keyof ScalarNames]: {
+        readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;
+    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];
+};
+/**
+ * Builder interface for declaring codecs.
+ */
+interface CodecDefBuilder<ScalarNames extends {
+    readonly [K in keyof ScalarNames]: Codec<string>;
+} = Record<never, never>> {
+    readonly CodecTypes: ExtractCodecTypes<ScalarNames>;
+    add<ScalarName extends string, CodecImpl extends Codec<string>>(scalarName: ScalarName, codecImpl: CodecImpl): CodecDefBuilder<O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>>;
+    readonly codecDefinitions: {
+        readonly [K in keyof ScalarNames]: {
+            readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown> ? Id : never;
+            readonly scalar: K;
+            readonly codec: ScalarNames[K];
+            readonly input: CodecInput<ScalarNames[K]>;
+            readonly output: CodecOutput<ScalarNames[K]>;
+            readonly jsType: CodecOutput<ScalarNames[K]>;
+        };
+    };
+    readonly dataTypes: {
+        readonly [K in keyof ScalarNames]: {
+            readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;
+        }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];
+    };
+}
+/**
+ * Create a new codec registry.
+ */
+declare function createCodecRegistry(): CodecRegistry;
+/**
+ * Create a new codec definition builder.
+ */
+declare function defineCodecs(): CodecDefBuilder<Record<never, never>>;
+
+/**
+ * Minimal context interface for SQL query lanes.
+ *
+ * Lanes only need contract, operations, and codecs to build typed ASTs and attach
+ * operation builders. This interface explicitly excludes runtime concerns like
+ * adapters, connection management, and transaction state.
+ */
+interface QueryLaneContext<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>> {
+    readonly contract: TContract;
+    readonly operations: OperationRegistry;
+    readonly codecs: CodecRegistry;
+}
+
+export { type CodecMeta as C, type ExtractCodecTypes as E, type QueryLaneContext as Q, type Codec as a, type CodecRegistry as b, codec as c, type CodecId as d, type CodecInput as e, type CodecOutput as f, type ExtractDataTypes as g, type CodecDefBuilder as h, createCodecRegistry as i, defineCodecs as j };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@prisma-next/sql-relational-core",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "description": "Schema and column builders, operation attachment, and AST types for Prisma Next",
+  "dependencies": {
+    "ts-toolbelt": "^9.6.0",
+    "@prisma-next/contract": "0.0.1",
+    "@prisma-next/plan": "0.0.1",
+    "@prisma-next/operations": "0.0.1",
+    "@prisma-next/sql-operations": "0.0.1",
+    "@prisma-next/sql-contract": "0.0.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^2.1.1",
+    "@prisma-next/sql-contract-ts": "0.0.1",
+    "@prisma-next/test-utils": "0.0.1"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/exports/schema.d.ts",
+      "import": "./dist/exports/schema.js"
+    },
+    "./param": {
+      "types": "./dist/exports/param.d.ts",
+      "import": "./dist/exports/param.js"
+    },
+    "./types": {
+      "types": "./dist/exports/types.d.ts",
+      "import": "./dist/exports/types.js"
+    },
+    "./operations-registry": {
+      "types": "./dist/exports/operations-registry.d.ts",
+      "import": "./dist/exports/operations-registry.js"
+    },
+    "./errors": {
+      "types": "./dist/exports/errors.d.ts",
+      "import": "./dist/exports/errors.js"
+    },
+    "./ast": {
+      "types": "./dist/exports/ast.d.ts",
+      "import": "./dist/exports/ast.js"
+    },
+    "./plan": {
+      "types": "./dist/exports/plan.d.ts",
+      "import": "./dist/exports/plan.js"
+    },
+    "./query-lane-context": {
+      "types": "./dist/exports/query-lane-context.d.ts",
+      "import": "./dist/exports/query-lane-context.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
+    "clean": "node ../../../../scripts/clean.mjs"
+  }
+}