@prisma-next/family-sql 0.3.0-dev.4 → 0.3.0-dev.41

package/src/core/verify.ts

@@ -0,0 +1,168 @@
+import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+import type { ControlDriverInstance } from '@prisma-next/core-control-plane/types';
+import { type } from 'arktype';
+
+const MetaSchema = type({ '[string]': 'unknown' });
+
+function parseMeta(meta: unknown): Record<string, unknown> {
+  if (meta === null || meta === undefined) {
+    return {};
+  }
+
+  let parsed: unknown;
+  if (typeof meta === 'string') {
+    try {
+      parsed = JSON.parse(meta);
+    } catch {
+      return {};
+    }
+  } else {
+    parsed = meta;
+  }
+
+  const result = MetaSchema(parsed);
+  if (result instanceof type.errors) {
+    return {};
+  }
+
+  return result as Record<string, unknown>;
+}
+
+const ContractMarkerRowSchema = type({
+  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',
+});
+
+/**
+ * Parses a contract marker row from database query result.
+ * This is SQL-specific parsing logic (handles SQL row structure with snake_case columns).
+ */
+export function parseContractMarkerRow(row: unknown): ContractMarkerRecord {
+  const result = ContractMarkerRowSchema(row);
+  if (result instanceof type.errors) {
+    const messages = result.map((p: { message: string }) => p.message).join('; ');
+    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)
+    : new Date();
+
+  return {
+    storageHash: validatedRow.core_hash,
+    profileHash: validatedRow.profile_hash,
+    contractJson: validatedRow.contract_json ?? null,
+    canonicalVersion: validatedRow.canonical_version ?? null,
+    updatedAt,
+    appTag: validatedRow.app_tag ?? null,
+    meta: parseMeta(validatedRow.meta),
+  };
+}
+
+/**
+ * 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],
+  };
+}
+
+/**
+ * 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> {
+  const markerStatement = readMarkerSql();
+
+  try {
+    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) {
+      // If rows array has length > 0 but first element is undefined, this is an unexpected result structure
+      throw new Error('Database query returned unexpected result structure');
+    }
+
+    return parseContractMarkerRow(markerRow);
+  } catch (error) {
+    // Handle case where marker table doesn't exist yet (empty database)
+    // PostgreSQL error code 42P01 = undefined_table
+    if (
+      error instanceof Error &&
+      (error.message.includes('does not exist') || (error as { code?: string }).code === '42P01')
+    ) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Collects supported codec type IDs from adapter and extension manifests.
+ * Returns a sorted, unique array of type IDs that are declared in the manifests.
+ * This enables coverage checks by comparing contract column types against supported types.
+ *
+ * Note: This extracts type IDs from manifest type imports, not from runtime codec registries.
+ * The manifests declare which codec types are available, but the actual type IDs
+ * are defined in the codec-types TypeScript modules that are imported.
+ *
+ * For MVP, we return an empty array since extracting type IDs from TypeScript modules
+ * would require runtime evaluation or static analysis. This can be enhanced later.
+ */
+export function collectSupportedCodecTypeIds(
+  descriptors: ReadonlyArray<{ readonly id: string }>,
+): readonly string[] {
+  // For MVP, return empty array
+  // Future enhancement: Extract type IDs from codec-types modules via static analysis
+  // or require manifests to explicitly list supported type IDs
+  void descriptors;
+  return [];
+}

package/src/exports/control-adapter.ts

@@ -0,0 +1 @@
+export type { SqlControlAdapter, SqlControlAdapterDescriptor } from '../core/control-adapter';

package/src/exports/control.ts

@@ -0,0 +1,59 @@
+import { SqlFamilyDescriptor } from '../core/control-descriptor';
+
+// Re-export core types from canonical source
+export type {
+  MigrationOperationClass,
+  MigrationOperationPolicy,
+  MigrationPlan,
+  MigrationPlanner,
+  MigrationPlannerConflict,
+  MigrationPlannerResult,
+  MigrationPlanOperation,
+  TargetMigrationsCapability,
+} from '@prisma-next/core-control-plane/types';
+export type { SqlControlDescriptorWithContributions } from '../core/assembly';
+export { extractCodecControlHooks } from '../core/assembly';
+export type { SchemaVerifyOptions, SqlControlFamilyInstance } from '../core/control-instance';
+export {
+  createMigrationPlan,
+  plannerFailure,
+  plannerSuccess,
+  runnerFailure,
+  runnerSuccess,
+} from '../core/migrations/plan-helpers';
+export { INIT_ADDITIVE_POLICY } from '../core/migrations/policies';
+// SQL-specific types
+export type {
+  CodecControlHooks,
+  ComponentDatabaseDependencies,
+  ComponentDatabaseDependency,
+  CreateSqlMigrationPlanOptions,
+  ExpandNativeTypeInput,
+  SqlControlAdapterDescriptor,
+  SqlControlExtensionDescriptor,
+  SqlControlStaticContributions,
+  SqlControlTargetDescriptor,
+  SqlMigrationPlan,
+  SqlMigrationPlanContractInfo,
+  SqlMigrationPlanner,
+  SqlMigrationPlannerPlanOptions,
+  SqlMigrationPlanOperation,
+  SqlMigrationPlanOperationStep,
+  SqlMigrationPlanOperationTarget,
+  SqlMigrationRunner,
+  SqlMigrationRunnerErrorCode,
+  SqlMigrationRunnerExecuteCallbacks,
+  SqlMigrationRunnerExecuteOptions,
+  SqlMigrationRunnerFailure,
+  SqlMigrationRunnerResult,
+  SqlMigrationRunnerSuccessValue,
+  SqlPlannerConflict,
+  SqlPlannerConflictKind,
+  SqlPlannerConflictLocation,
+  SqlPlannerFailureResult,
+  SqlPlannerResult,
+  SqlPlannerSuccessResult,
+  StorageTypePlanResult,
+} from '../core/migrations/types';
+
+export default new SqlFamilyDescriptor();

package/src/exports/runtime.ts

@@ -0,0 +1,3 @@
+import { sqlRuntimeFamilyDescriptor } from '../core/runtime-descriptor';
+
+export default sqlRuntimeFamilyDescriptor;

package/src/exports/schema-verify.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure schema verification exports.
+ *
+ * This module exports the pure schema verification function that can be used
+ * without a database connection. It's suitable for migration planning and
+ * other tools that need to compare schema states.
+ */
+
+export {
+  arraysEqual,
+  isIndexSatisfied,
+  isUniqueConstraintSatisfied,
+  verifyDatabaseDependencies,
+} from '../core/schema-verify/verify-helpers';
+export type {
+  NativeTypeNormalizer,
+  VerifySqlSchemaOptions,
+} from '../core/schema-verify/verify-sql-schema';
+export { verifySqlSchema } from '../core/schema-verify/verify-sql-schema';

package/src/exports/test-utils.ts

@@ -0,0 +1,10 @@
+/**
+ * Test utilities for working with component descriptors.
+ * These functions operate on descriptors directly, used in tests and integration tests.
+ */
+export {
+  assembleOperationRegistry,
+  extractCodecTypeImports,
+  extractExtensionIds,
+  extractOperationTypeImports,
+} from '../core/assembly';

package/src/exports/verify.ts

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