@prisma-next/family-sql 0.5.0-dev.9 → 0.5.1

package/src/core/schema-verify/verify-helpers.ts

@@ -13,13 +13,40 @@ import type {
   PrimaryKey,
   UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
-import type {
-  SqlForeignKeyIR,
-  SqlIndexIR,
-  SqlSchemaIR,
-  SqlUniqueIR,
-} from '@prisma-next/sql-schema-ir/types';
-import type { ComponentDatabaseDependency } from '../migrations/types';
+import type { SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from '@prisma-next/sql-schema-ir/types';
+
+function indexOptionsLooselyEqual(
+  a: Record<string, unknown> | undefined,
+  b: Record<string, unknown> | undefined,
+): boolean {
+  const aKeys = a ? Object.keys(a).sort() : [];
+  const bKeys = b ? Object.keys(b).sort() : [];
+  if (aKeys.length !== bKeys.length) return false;
+  for (let i = 0; i < aKeys.length; i += 1) {
+    if (aKeys[i] !== bKeys[i]) return false;
+  }
+  if (aKeys.length === 0) return true;
+  for (const key of aKeys) {
+    // Postgres introspection returns reloptions values as raw strings (e.g.
+    // `'70'`, `'false'`), while contract option leaves are typed (number,
+    // boolean, string). Compare via String() so a contract `fillfactor: 70`
+    // matches an introspected `fillfactor: '70'` without a spurious mismatch.
+    if (
+      String((a as Record<string, unknown>)[key]) !== String((b as Record<string, unknown>)[key])
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function indexExtrasMatch(
+  contractIndex: Index,
+  schemaIndex: { readonly type?: string; readonly options?: Record<string, unknown> },
+): boolean {
+  if ((contractIndex.type ?? null) !== (schemaIndex.type ?? null)) return false;
+  return indexOptionsLooselyEqual(contractIndex.options, schemaIndex.options);
+}
 
 /**
  * Compares two arrays of strings for equality (order-sensitive).
@@ -391,13 +418,19 @@ export function verifyIndexes(
 
     // Check for any matching index (unique or non-unique)
     // A unique index can satisfy a non-unique index requirement (stronger satisfies weaker)
-    const matchingIndex = schemaIndexes.find((idx) =>
-      arraysEqual(idx.columns, contractIndex.columns),
+    const matchingIndex = schemaIndexes.find(
+      (idx) =>
+        arraysEqual(idx.columns, contractIndex.columns) && indexExtrasMatch(contractIndex, idx),
     );
 
-    // Also check if a unique constraint satisfies the index requirement
+    // Also check if a unique constraint satisfies the index requirement.
+    // Unique constraints carry no type/options of their own, so they can only
+    // satisfy a contract index that doesn't request a specific type/options.
     const matchingUniqueConstraint =
-      !matchingIndex && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
+      !matchingIndex &&
+      contractIndex.type === undefined &&
+      contractIndex.options === undefined &&
+      schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
 
     if (!matchingIndex && !matchingUniqueConstraint) {
       issues.push({
@@ -442,8 +475,9 @@ export function verifyIndexes(
         continue;
       }
 
-      const matchingIndex = contractIndexes.find((idx) =>
-        arraysEqual(idx.columns, schemaIndex.columns),
+      const matchingIndex = contractIndexes.find(
+        (idx) =>
+          arraysEqual(idx.columns, schemaIndex.columns) && indexExtrasMatch(idx, schemaIndex),
       );
 
       if (!matchingIndex) {
@@ -471,63 +505,6 @@ export function verifyIndexes(
   return nodes;
 }
 
-/**
- * Verifies database dependencies are installed using component-owned verification hooks.
- * Checks whether each dependency is satisfied by verifying its id is present in
- * schema.dependencies (populated from introspection).
- *
- * Returns verification nodes for the tree.
- */
-export function verifyDatabaseDependencies(
-  dependencies: ReadonlyArray<ComponentDatabaseDependency<unknown>>,
-  schema: SqlSchemaIR,
-  issues: SchemaIssue[],
-): SchemaVerificationNode[] {
-  const nodes: SchemaVerificationNode[] = [];
-  const installedIds = new Set(schema.dependencies.map((d) => d.id));
-
-  for (const dependency of dependencies) {
-    const isSatisfied = installedIds.has(dependency.id);
-    const depPath = `dependencies.${dependency.id}`;
-
-    if (!isSatisfied) {
-      const depIssue: SchemaIssue = {
-        kind: 'dependency_missing',
-        dependencyId: dependency.id,
-        message: `Dependency "${dependency.id}" is missing from database`,
-      };
-      issues.push(depIssue);
-      const nodeMessage = depIssue.message;
-      nodes.push({
-        status: 'fail',
-        kind: 'databaseDependency',
-        name: dependency.label,
-        contractPath: depPath,
-        code: 'dependency_missing',
-        message: nodeMessage,
-        expected: undefined,
-        actual: undefined,
-        children: [],
-      });
-    } else {
-      // Dependency is satisfied
-      nodes.push({
-        status: 'pass',
-        kind: 'databaseDependency',
-        name: dependency.label,
-        contractPath: depPath,
-        code: '',
-        message: '',
-        expected: undefined,
-        actual: undefined,
-        children: [],
-      });
-    }
-  }
-
-  return nodes;
-}
-
 /**
  * Computes counts of pass/warn/fail nodes by traversing the tree.
  */

package/src/core/schema-verify/verify-sql-schema.ts

@@ -22,11 +22,10 @@ import type {
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { extractCodecControlHooks } from '../assembly';
-import { type CodecControlHooks, collectInitDependencies } from '../migrations/types';
+import type { CodecControlHooks } from '../migrations/types';
 import {
   arraysEqual,
   computeCounts,
-  verifyDatabaseDependencies,
   verifyForeignKeys,
   verifyIndexes,
   verifyPrimaryKey,
@@ -166,10 +165,6 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
     });
   }
 
-  const databaseDependencies = collectInitDependencies(options.frameworkComponents);
-  const dependencyStatuses = verifyDatabaseDependencies(databaseDependencies, schema, issues);
-  rootChildren.push(...dependencyStatuses);
-
   const root = buildRootNode(rootChildren);
 
   // Compute counts

package/src/core/sql-migration.ts

@@ -1,34 +1,36 @@
+import { deriveProvidedInvariants } from '@prisma-next/migration-tools/invariants';
 import { Migration } from '@prisma-next/migration-tools/migration';
-import type { AnySqlMigrationOperation, SqlPlanTargetDetails } from './migrations/types';
+import type { SqlMigrationPlanOperation, SqlPlanTargetDetails } from './migrations/types';
 
 /**
  * Family-owned base class for SQL migrations.
  *
- * Parameterized on the target-details shape because SQL-family targets
- * (Postgres, MySQL, SQLite, …) each carry their own `target.details` payload
- * on `SqlMigrationPlanOperation`. The type parameter is narrowed to
- * `SqlPlanTargetDetails` so every target-specific shape must at minimum
- * identify the object being targeted (schema + name); concrete targets
- * extend the shape with their own fields.
+ * Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)
+ * and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).
  *
- * Each concrete target-side subclass (e.g. Postgres's
- * `TypeScriptRenderablePostgresMigration`) fixes `targetId` to its own
- * target-id string literal, since SQL can't hardcode a single `targetId`:
- * `targetId` is a target-level identity, not a family-level one, and
- * belongs on the subclass.
+ * Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and
+ * a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the
+ * fully concrete operation shape. Target-free code in SQL family / tooling
+ * parameterises over `TDetails` (and usually `TTargetId = string`).
  *
- * `familyId` is intentionally not declared here. The SQL family has no
- * family-scoped runtime identity today — consumers reach the family via
- * target descriptors rather than by family-id lookup, so adding one would
- * be purely decorative. Introducing it later is a non-breaking superset.
- *
- * The operation type parameter is `AnySqlMigrationOperation<TDetails>` — the
- * union of DDL-shaped `SqlMigrationPlanOperation` and `DataTransformOperation`
- * — so subclasses can return a mix of schema operations (e.g. `setNotNull`,
- * `addColumn`) and data-transform operations (e.g. `dataTransform`). Mirrors
- * `MongoMigration`'s parameterization on `AnyMongoMigrationOperation`.
+ * Keeps target-free contract/runtime features in the family layer while
+ * letting adapters own target shape.
  */
 export abstract class SqlMigration<
   TDetails extends SqlPlanTargetDetails,
   TTargetId extends string = string,
-> extends Migration<AnySqlMigrationOperation<TDetails>, 'sql', TTargetId> {}
+> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId> {
+  /**
+   * Sorted, deduplicated invariant ids declared by this migration's
+   * data-transform ops. Derived from `this.operations` so the field remains
+   * consistent with the operation list — planner-built plans (`db init`,
+   * `db update`) yield `[]` because they emit no data-transform ops.
+   *
+   * Required by `SqlMigrationPlan.providedInvariants` (tightened from
+   * optional at the SQL-family layer); the framework-level
+   * `MigrationPlan.providedInvariants?` stays optional.
+   */
+  get providedInvariants(): readonly string[] {
+    return deriveProvidedInvariants(this.operations);
+  }
+}

package/src/core/timestamp-now-generator.ts

@@ -0,0 +1,74 @@
+import type { AuthoringFieldPresetDescriptor } from '@prisma-next/framework-components/authoring';
+import type { MutationDefaultGeneratorDescriptor } from '@prisma-next/framework-components/control';
+
+/**
+ * Canonical id for the wall-clock-now mutation default generator.
+ *
+ * Owned by `family-sql` because that's where the generator lives. The
+ * id flows out from here to (1) the control-plane descriptor and the
+ * temporal field-preset pair below, (2) the runtime-plane sibling
+ * `timestamp-now-runtime-generator.ts`, and (3) authoring surfaces
+ * (PSL `temporal.updatedAt()`, TS `field.temporal.updatedAt()`) via
+ * the descriptor flow. Co-locating the constant with its only owner
+ * keeps the framework layer free of concrete generator ids.
+ */
+export const TIMESTAMP_NOW_GENERATOR_ID = 'timestampNow' as const;
+
+/**
+ * Builds the canonical control-plane descriptor for the wall-clock-now
+ * mutation default generator. The descriptor's `id` and `buildPhases`
+ * are target-agnostic so PSL `temporal.updatedAt()` and TS
+ * `field.temporal.updatedAt()` lower to byte-identical contracts.
+ *
+ * `applicableCodecIds` is omitted: `timestampNow` is preset-only (not
+ * reachable via `@default(timestampNow())` lowering), and the codec is
+ * co-registered by the preset descriptor itself, so the
+ * `@default(...)` compatibility check has no role to play here.
+ */
+export function timestampNowControlDescriptor(): MutationDefaultGeneratorDescriptor {
+  return {
+    id: TIMESTAMP_NOW_GENERATOR_ID,
+    buildPhases: () => ({
+      onCreate: { kind: 'generator', id: TIMESTAMP_NOW_GENERATOR_ID },
+      onUpdate: { kind: 'generator', id: TIMESTAMP_NOW_GENERATOR_ID },
+    }),
+  };
+}
+
+/**
+ * Builds the canonical `temporal.{createdAt,updatedAt}` field-preset pair
+ * for a SQL target. `createdAt` lowers to a `now()` storage default;
+ * `updatedAt` lowers to the `timestampNow` execution generator on both
+ * `onCreate` and `onUpdate` (RD: "last modified time", non-null). Targets
+ * supply the codec/native-type pair that matches their timestamp column;
+ * everything else is shared so PSL `temporal.updatedAt()` and TS
+ * `field.temporal.updatedAt()` lower to byte-identical contracts across
+ * targets by construction.
+ */
+export function temporalAuthoringPresets<
+  const CodecId extends string,
+  const NativeType extends string,
+>(input: { readonly codecId: CodecId; readonly nativeType: NativeType }) {
+  const { codecId, nativeType } = input;
+  return {
+    createdAt: {
+      kind: 'fieldPreset',
+      output: {
+        codecId,
+        nativeType,
+        default: { kind: 'function', expression: 'now()' },
+      },
+    },
+    updatedAt: {
+      kind: 'fieldPreset',
+      output: {
+        codecId,
+        nativeType,
+        executionDefaults: {
+          onCreate: { kind: 'generator', id: TIMESTAMP_NOW_GENERATOR_ID },
+          onUpdate: { kind: 'generator', id: TIMESTAMP_NOW_GENERATOR_ID },
+        },
+      },
+    },
+  } as const satisfies Record<string, AuthoringFieldPresetDescriptor>;
+}

package/src/core/timestamp-now-runtime-generator.ts

@@ -0,0 +1,24 @@
+import type { RuntimeMutationDefaultGenerator } from '@prisma-next/sql-runtime';
+import { TIMESTAMP_NOW_GENERATOR_ID } from './timestamp-now-generator';
+
+/**
+ * Builds the canonical runtime-plane generator for the wall-clock-now
+ * mutation default. Returns `new Date()`; semantics are target-agnostic
+ * so all SQL targets share this single implementation.
+ *
+ * Declares `stability: 'query'` so a single ORM bulk operation
+ * (e.g. `createAll([...])`) shares one timestamp across every row and
+ * every timestamp-defaulted column. Matches Prisma 6's `@updatedAt`
+ * semantics: one `new Date()` per lowered mutation, not per row.
+ *
+ * Lives in a runtime-plane-only module so the control-plane
+ * `timestamp-now-generator.ts` (descriptor + authoring presets) stays
+ * free of `@prisma-next/sql-runtime` imports.
+ */
+export function timestampNowRuntimeGenerator(): RuntimeMutationDefaultGenerator {
+  return {
+    id: TIMESTAMP_NOW_GENERATOR_ID,
+    generate: () => new Date(),
+    stability: 'query',
+  };
+}

package/src/core/verify.ts

@@ -1,5 +1,4 @@
 import type { ContractMarkerRecord } from '@prisma-next/contract/types';
-import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
 import { type } from 'arktype';
 
 const MetaSchema = type({ '[string]': 'unknown' });
@@ -28,6 +27,40 @@ function parseMeta(meta: unknown): Record<string, unknown> {
   return result as Record<string, unknown>;
 }
 
+/**
+ * SQLite stores `contract_json` as TEXT, so the wire shape is a JSON string;
+ * Postgres uses `jsonb` and returns an already-parsed value. Normalize both
+ * here so `ContractMarkerRecord.contractJson` is always the structured form.
+ */
+function parseContractJson(value: unknown): unknown {
+  if (value === null || value === undefined) return null;
+  if (typeof value !== 'string') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Wire shape of a `prisma_contract.marker` row as it comes out of a SQL
+ * driver. Snake-cased to match the on-disk column names. Shared by every
+ * SQL target's `readMarker` so each runner doesn't redeclare it inline.
+ */
+export type ContractMarkerRow = {
+  core_hash: string;
+  profile_hash: string;
+  contract_json: unknown | null;
+  canonical_version: number | null;
+  updated_at: Date | string;
+  app_tag: string | null;
+  meta: unknown | null;
+  // SQLite stores arrays as JSON-TEXT, so this is `string` on the wire from
+  // a SQLite driver and `string[]` from a Postgres driver. Targets normalize
+  // before passing to `parseContractMarkerRow`.
+  invariants: unknown;
+};
+
 const ContractMarkerRowSchema = type({
   core_hash: 'string',
   profile_hash: 'string',
@@ -36,6 +69,7 @@ const ContractMarkerRowSchema = type({
   'updated_at?': 'Date | string',
   'app_tag?': 'string | null',
   'meta?': 'unknown | null',
+  invariants: type('string').array(),
 });
 
 /**
@@ -49,120 +83,24 @@ export function parseContractMarkerRow(row: unknown): ContractMarkerRecord {
     throw new Error(`Invalid contract marker row: ${messages}`);
   }
 
-  const validatedRow = result as {
-    core_hash: string;
-    profile_hash: string;
-    contract_json?: unknown | null;
-    canonical_version?: number | null;
-    updated_at?: Date | string;
-    app_tag?: string | null;
-    meta?: unknown | null;
-  };
-
-  const updatedAt = validatedRow.updated_at
-    ? validatedRow.updated_at instanceof Date
-      ? validatedRow.updated_at
-      : new Date(validatedRow.updated_at)
+  const updatedAt = result.updated_at
+    ? result.updated_at instanceof Date
+      ? result.updated_at
+      : new Date(result.updated_at)
     : new Date();
 
   return {
-    storageHash: validatedRow.core_hash,
-    profileHash: validatedRow.profile_hash,
-    contractJson: validatedRow.contract_json ?? null,
-    canonicalVersion: validatedRow.canonical_version ?? null,
+    storageHash: result.core_hash,
+    profileHash: result.profile_hash,
+    contractJson: parseContractJson(result.contract_json),
+    canonicalVersion: result.canonical_version ?? null,
     updatedAt,
-    appTag: validatedRow.app_tag ?? null,
-    meta: parseMeta(validatedRow.meta),
+    appTag: result.app_tag ?? null,
+    meta: parseMeta(result.meta),
+    invariants: result.invariants,
   };
 }
 
-/**
- * Returns the SQL statement to read the contract marker.
- * This is a migration-plane helper (no runtime imports).
- * @internal - Used internally by readMarker(). Prefer readMarker() for Control Plane usage.
- */
-export function readMarkerSql(): { readonly sql: string; readonly params: readonly unknown[] } {
-  return {
-    sql: `select
-      core_hash,
-      profile_hash,
-      contract_json,
-      canonical_version,
-      updated_at,
-      app_tag,
-      meta
-    from prisma_contract.marker
-    where id = $1`,
-    params: [1],
-  };
-}
-
-/**
- * Returns the SQL statement that probes for the existence of the marker table.
- * Uses the SQL-standard `information_schema.tables` view so the query succeeds
- * (returning zero rows) when the table has not been created yet — avoiding a
- * `relation does not exist` error. Some Postgres wire-protocol implementations
- * (e.g. PGlite's TCP proxy) do not fully recover from an extended-protocol
- * parse error, so we probe first instead of relying on an error signal.
- * @internal - Used internally by readMarker().
- */
-export function markerTableExistsSql(): {
-  readonly sql: string;
-  readonly params: readonly unknown[];
-} {
-  return {
-    sql: `select 1
-    from information_schema.tables
-    where table_schema = $1 and table_name = $2`,
-    params: ['prisma_contract', 'marker'],
-  };
-}
-
-/**
- * Reads the contract marker from the database using the provided driver.
- * Returns the parsed marker record or null if no marker is found.
- * This abstracts SQL-specific details from the Control Plane.
- *
- * @param driver - ControlDriverInstance instance for executing queries
- * @returns Promise resolving to ContractMarkerRecord or null if marker not found
- */
-export async function readMarker(
-  driver: ControlDriverInstance<'sql', string>,
-): Promise<ContractMarkerRecord | null> {
-  // Probe for the marker table first so that a fresh database (no
-  // `prisma_contract` schema) returns null cleanly instead of surfacing a
-  // `relation does not exist` error. This keeps the control connection in a
-  // predictable state for driver implementations that are sensitive to
-  // extended-protocol parse errors.
-  const existsStatement = markerTableExistsSql();
-  const existsResult = await driver.query(existsStatement.sql, existsStatement.params);
-  if (existsResult.rows.length === 0) {
-    return null;
-  }
-
-  const markerStatement = readMarkerSql();
-  const queryResult = await driver.query<{
-    core_hash: string;
-    profile_hash: string;
-    contract_json: unknown | null;
-    canonical_version: number | null;
-    updated_at: Date | string;
-    app_tag: string | null;
-    meta: unknown | null;
-  }>(markerStatement.sql, markerStatement.params);
-
-  if (queryResult.rows.length === 0) {
-    return null;
-  }
-
-  const markerRow = queryResult.rows[0];
-  if (!markerRow) {
-    throw new Error('Database query returned unexpected result structure');
-  }
-
-  return parseContractMarkerRow(markerRow);
-}
-
 /**
  * Collects supported codec type IDs from adapter and extension manifests.
  * Returns a sorted, unique array of type IDs that are declared in the manifests.

package/src/exports/control.ts

@@ -24,6 +24,8 @@ export {
   contractToSchemaIR,
   detectDestructiveChanges,
 } from '../core/migrations/contract-to-schema-ir';
+export type { PlanFieldEventOperationsOptions } from '../core/migrations/field-event-planner';
+export { planFieldEventOperations } from '../core/migrations/field-event-planner';
 export {
   createMigrationPlan,
   plannerFailure,
@@ -33,12 +35,14 @@ export {
 } from '../core/migrations/plan-helpers';
 export { INIT_ADDITIVE_POLICY } from '../core/migrations/policies';
 export type {
-  AnySqlMigrationOperation,
   CodecControlHooks,
-  ComponentDatabaseDependencies,
-  ComponentDatabaseDependency,
   CreateSqlMigrationPlanOptions,
   ExpandNativeTypeInput,
+  FieldEvent,
+  FieldEventContext,
+  MultiSpaceRunnerFailure,
+  MultiSpaceRunnerResult,
+  MultiSpaceRunnerSuccessValue,
   ResolveIdentityValueInput,
   SqlControlAdapterDescriptor,
   SqlControlExtensionDescriptor,
@@ -66,6 +70,9 @@ export type {
   SqlPlanTargetDetails,
   StorageTypePlanResult,
 } from '../core/migrations/types';
-export { collectInitDependencies, isDatabaseDependencyProvider } from '../core/migrations/types';
+export {
+  temporalAuthoringPresets,
+  timestampNowControlDescriptor,
+} from '../core/timestamp-now-generator';
 
 export default new SqlFamilyDescriptor();

package/src/exports/runtime.ts

@@ -1,3 +1,5 @@
 import { sqlRuntimeFamilyDescriptor } from '../core/runtime-descriptor';
 
+export { timestampNowRuntimeGenerator } from '../core/timestamp-now-runtime-generator';
+
 export default sqlRuntimeFamilyDescriptor;

package/src/exports/schema-verify.ts

@@ -10,7 +10,6 @@ export {
   arraysEqual,
   isIndexSatisfied,
   isUniqueConstraintSatisfied,
-  verifyDatabaseDependencies,
 } from '../core/schema-verify/verify-helpers';
 export type {
   NativeTypeNormalizer,

package/src/exports/test-utils.ts

@@ -5,6 +5,5 @@
 export {
   extractCodecTypeImports,
   extractComponentIds,
-  extractOperationTypeImports,
   extractQueryOperationTypeImports,
 } from '@prisma-next/framework-components/control';

package/src/exports/verify.ts

@@ -1 +1 @@
-export { parseContractMarkerRow, readMarker, readMarkerSql } from '../core/verify';
+export { type ContractMarkerRow, parseContractMarkerRow } from '../core/verify';

package/dist/authoring-type-constructors-BAR65pSK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring-type-constructors-BAR65pSK.mjs","names":[],"sources":["../src/core/authoring-field-presets.ts","../src/core/authoring-type-constructors.ts"],"sourcesContent":["import type { AuthoringFieldNamespace } from '@prisma-next/framework-components/authoring';\n\n/**\n * Family-level SQL authoring field presets.\n *\n * Only presets whose codec IDs align with the ID generator metadata live here\n * (see `@prisma-next/ids`). These presets are target-agnostic because the\n * generator metadata fixes their codec/native-type to `sql/char@1`\n * (`character`) regardless of target, and the PSL interpreter lets the\n * generator override the scalar descriptor.\n *\n * Scalar presets that map to target-specific codecs (e.g. `text`, `int`,\n * `boolean`, `dateTime`) are contributed by the target pack (see\n * `postgresAuthoringFieldPresets` in `@prisma-next/target-postgres`) so the\n * TS callback surface and the PSL scalar surface lower to byte-identical\n * contracts for the active target.\n */\n\nconst CHARACTER_CODEC_ID = 'sql/char@1';\nconst CHARACTER_NATIVE_TYPE = 'character';\n\nconst nanoidOptionsArgument = {\n  kind: 'object',\n  optional: true,\n  properties: {\n    size: {\n      kind: 'number',\n      optional: true,\n      integer: true,\n      minimum: 2,\n      maximum: 255,\n    },\n  },\n} as const;\n\nexport const sqlFamilyAuthoringFieldPresets = {\n  uuid: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 36,\n      },\n    },\n  },\n  ulid: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 26,\n      },\n    },\n  },\n  nanoid: {\n    kind: 'fieldPreset',\n    args: [nanoidOptionsArgument],\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: {\n          kind: 'arg',\n          index: 0,\n          path: ['size'],\n          default: 21,\n        },\n      },\n    },\n  },\n  cuid2: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 24,\n      },\n    },\n  },\n  ksuid: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 27,\n      },\n    },\n  },\n  id: {\n    uuidv4: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 36,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'uuidv4',\n        },\n        id: true,\n      },\n    },\n    uuidv7: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 36,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'uuidv7',\n        },\n        id: true,\n      },\n    },\n    ulid: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 26,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'ulid',\n        },\n        id: true,\n      },\n    },\n    nanoid: {\n      kind: 'fieldPreset',\n      args: [nanoidOptionsArgument],\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: {\n            kind: 'arg',\n            index: 0,\n            path: ['size'],\n            default: 21,\n          },\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'nanoid',\n          params: {\n            size: {\n              kind: 'arg',\n              index: 0,\n              path: ['size'],\n            },\n          },\n        },\n        id: true,\n      },\n    },\n    cuid2: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 24,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'cuid2',\n        },\n        id: true,\n      },\n    },\n    ksuid: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 27,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'ksuid',\n        },\n        id: true,\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n","import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';\n\nexport const sqlFamilyAuthoringTypes = {\n  sql: {\n    String: {\n      kind: 'typeConstructor',\n      args: [{ kind: 'number', name: 'length', integer: true, minimum: 1, maximum: 10485760 }],\n      output: {\n        codecId: 'sql/varchar@1',\n        nativeType: 'character varying',\n        typeParams: {\n          length: { kind: 'arg', index: 0 },\n        },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,MAAM,qBAAqB;AAC3B,MAAM,wBAAwB;AAE9B,MAAM,wBAAwB;CAC5B,MAAM;CACN,UAAU;CACV,YAAY,EACV,MAAM;EACJ,MAAM;EACN,UAAU;EACV,SAAS;EACT,SAAS;EACT,SAAS;EACV,EACF;CACF;AAED,MAAa,iCAAiC;CAC5C,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,YAAY,EACV,QAAQ,IACT;GACF;EACF;CACD,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,YAAY,EACV,QAAQ,IACT;GACF;EACF;CACD,QAAQ;EACN,MAAM;EACN,MAAM,CAAC,sBAAsB;EAC7B,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,YAAY,EACV,QAAQ;IACN,MAAM;IACN,OAAO;IACP,MAAM,CAAC,OAAO;IACd,SAAS;IACV,EACF;GACF;EACF;CACD,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,YAAY,EACV,QAAQ,IACT;GACF;EACF;CACD,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,YAAY,EACV,QAAQ,IACT;GACF;EACF;CACD,IAAI;EACF,QAAQ;GACN,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,YAAY,EACV,QAAQ,IACT;IACD,kBAAkB;KAChB,MAAM;KACN,IAAI;KACL;IACD,IAAI;IACL;GACF;EACD,QAAQ;GACN,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,YAAY,EACV,QAAQ,IACT;IACD,kBAAkB;KAChB,MAAM;KACN,IAAI;KACL;IACD,IAAI;IACL;GACF;EACD,MAAM;GACJ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,YAAY,EACV,QAAQ,IACT;IACD,kBAAkB;KAChB,MAAM;KACN,IAAI;KACL;IACD,IAAI;IACL;GACF;EACD,QAAQ;GACN,MAAM;GACN,MAAM,CAAC,sBAAsB;GAC7B,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,YAAY,EACV,QAAQ;KACN,MAAM;KACN,OAAO;KACP,MAAM,CAAC,OAAO;KACd,SAAS;KACV,EACF;IACD,kBAAkB;KAChB,MAAM;KACN,IAAI;KACJ,QAAQ,EACN,MAAM;MACJ,MAAM;MACN,OAAO;MACP,MAAM,CAAC,OAAO;MACf,EACF;KACF;IACD,IAAI;IACL;GACF;EACD,OAAO;GACL,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,YAAY,EACV,QAAQ,IACT;IACD,kBAAkB;KAChB,MAAM;KACN,IAAI;KACL;IACD,IAAI;IACL;GACF;EACD,OAAO;GACL,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,YAAY,EACV,QAAQ,IACT;IACD,kBAAkB;KAChB,MAAM;KACN,IAAI;KACL;IACD,IAAI;IACL;GACF;EACF;CACF;;;;ACnMD,MAAa,0BAA0B,EACrC,KAAK,EACH,QAAQ;CACN,MAAM;CACN,MAAM,CAAC;EAAE,MAAM;EAAU,MAAM;EAAU,SAAS;EAAM,SAAS;EAAG,SAAS;EAAU,CAAC;CACxF,QAAQ;EACN,SAAS;EACT,YAAY;EACZ,YAAY,EACV,QAAQ;GAAE,MAAM;GAAO,OAAO;GAAG,EAClC;EACF;CACF,EACF,EACF"}