@prisma-next/cli 0.3.0-dev.45 → 0.3.0-dev.52

package/src/control-api/client.ts

@@ -506,7 +506,6 @@ class ControlClientImpl implements ControlClient {
       throw new Error('Family instance was not initialized. This is a bug.');
     }
 
-    // Resolve contract source
     let contractRaw: unknown;
     onProgress?.({
       action: 'emit',
@@ -516,14 +515,24 @@ class ControlClientImpl implements ControlClient {
     });
 
     try {
-      switch (contractConfig.source.kind) {
-        case 'loader':
-          contractRaw = await contractConfig.source.load();
-          break;
-        case 'value':
-          contractRaw = contractConfig.source.value;
-          break;
+      const providerResult = await contractConfig.sourceProvider();
+      if (!providerResult.ok) {
+        onProgress?.({
+          action: 'emit',
+          kind: 'spanEnd',
+          spanId: 'resolveSource',
+          outcome: 'error',
+        });
+
+        return notOk({
+          code: 'CONTRACT_SOURCE_INVALID',
+          summary: providerResult.failure.summary,
+          why: providerResult.failure.summary,
+          meta: providerResult.failure.meta,
+          diagnostics: providerResult.failure,
+        });
       }
+      contractRaw = providerResult.value;
 
       onProgress?.({
         action: 'emit',
@@ -539,10 +548,20 @@ class ControlClientImpl implements ControlClient {
         outcome: 'error',
       });
 
+      const message = error instanceof Error ? error.message : String(error);
       return notOk({
         code: 'CONTRACT_SOURCE_INVALID',
         summary: 'Failed to resolve contract source',
-        why: error instanceof Error ? error.message : String(error),
+        why: message,
+        diagnostics: {
+          summary: 'Contract source provider threw an exception',
+          diagnostics: [
+            {
+              code: 'PROVIDER_THROW',
+              message,
+            },
+          ],
+        },
         meta: undefined,
       });
     }

package/src/control-api/operations/contract-emit.ts

@@ -4,9 +4,29 @@ import { abortable } from '@prisma-next/utils/abortable';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { dirname, isAbsolute, join, resolve } from 'pathe';
 import { loadConfig } from '../../config-loader';
-import { errorContractConfigMissing } from '../../utils/cli-errors';
+import { errorContractConfigMissing, errorRuntime } from '../../utils/cli-errors';
 import type { ContractEmitOptions, ContractEmitResult } from '../types';
 
+interface ProviderFailureLike {
+  readonly summary: string;
+  readonly diagnostics: readonly unknown[];
+  readonly meta?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isAbortError(error: unknown): boolean {
+  return isRecord(error) && typeof error['name'] === 'string' && error['name'] === 'AbortError';
+}
+
+function isProviderFailureLike(value: unknown): value is ProviderFailureLike {
+  return (
+    isRecord(value) && typeof value['summary'] === 'string' && Array.isArray(value['diagnostics'])
+  );
+}
+
 /**
  * Executes the contract emit operation.
  *
@@ -54,13 +74,10 @@ export async function executeContractEmit(
     });
   }
 
-  // Validate source is defined and is either a function or a non-null object
-  if (
-    contractConfig.source === null ||
-    (typeof contractConfig.source !== 'function' && typeof contractConfig.source !== 'object')
-  ) {
+  // Validate source exists and is callable
+  if (typeof contractConfig.source !== 'function') {
     throw errorContractConfigMissing({
-      why: 'Contract config must include a valid source (function or non-null object)',
+      why: 'Contract config must include a valid source provider function',
     });
   }
 
@@ -73,18 +90,59 @@ export async function executeContractEmit(
   // Colocate .d.ts with .json (contract.json → contract.d.ts)
   const outputDtsPath = `${outputJsonPath.slice(0, -5)}.d.ts`;
 
+  let providerResult: Awaited<ReturnType<typeof contractConfig.source>>;
+  try {
+    providerResult = await unlessAborted(contractConfig.source());
+  } catch (error) {
+    if (signal.aborted || isAbortError(error)) {
+      throw error;
+    }
+    throw errorRuntime('Failed to resolve contract source', {
+      why: error instanceof Error ? error.message : String(error),
+      fix: 'Ensure contract.source resolves to ok(contractIR) or returns structured diagnostics.',
+    });
+  }
+
+  if (!isRecord(providerResult) || typeof providerResult.ok !== 'boolean') {
+    throw errorRuntime('Failed to resolve contract source', {
+      why: 'Contract source provider returned malformed result shape.',
+      fix: 'Ensure contract.source resolves to ok(contractIR) or notOk({ summary, diagnostics }).',
+    });
+  }
+
+  if (providerResult.ok && !('value' in providerResult)) {
+    throw errorRuntime('Failed to resolve contract source', {
+      why: 'Contract source provider returned malformed success result: missing value.',
+      fix: 'Ensure contract.source success payload is ok(contractIR).',
+    });
+  }
+
+  if (!providerResult.ok && !isProviderFailureLike(providerResult.failure)) {
+    throw errorRuntime('Failed to resolve contract source', {
+      why: 'Contract source provider returned malformed failure result: expected summary and diagnostics.',
+      fix: 'Ensure contract.source failure payload is notOk({ summary, diagnostics, meta? }).',
+    });
+  }
+
+  if (!providerResult.ok) {
+    throw errorRuntime('Failed to resolve contract source', {
+      why: providerResult.failure.summary,
+      fix: 'Fix contract source diagnostics and return ok(contractIR).',
+      meta: {
+        diagnostics: providerResult.failure.diagnostics,
+        ...ifDefined('providerMeta', providerResult.failure.meta),
+      },
+    });
+  }
+
   // Create control plane stack from config
   const stack = createControlPlaneStack(config);
   const familyInstance = config.family.create(stack);
 
-  // Resolve contract source from config
-  const contractRaw =
-    typeof contractConfig.source === 'function'
-      ? await unlessAborted(contractConfig.source())
-      : contractConfig.source;
-
   // Emit contract via family instance
-  const emitResult = await unlessAborted(familyInstance.emitContract({ contractIR: contractRaw }));
+  const emitResult = await unlessAborted(
+    familyInstance.emitContract({ contractIR: providerResult.value }),
+  );
 
   // Create directory if needed and write files (both colocated)
   await unlessAborted(mkdir(dirname(outputJsonPath), { recursive: true }));

package/src/control-api/types.ts

@@ -1,3 +1,7 @@
+import type {
+  ContractSourceDiagnostics,
+  ContractSourceProvider,
+} from '@prisma-next/core-control-plane/config-types';
 import type { CoreSchemaView } from '@prisma-next/core-control-plane/schema-view';
 import type {
   ControlAdapterDescriptor,
@@ -203,37 +207,14 @@ export interface IntrospectOptions {
   readonly onProgress?: OnControlProgress;
 }
 
-/**
- * Contract source as a raw value (any JSON-serializable value).
- */
-export interface ContractSourceValue {
-  readonly kind: 'value';
-  readonly value: unknown;
-}
-
-/**
- * Contract source as a lazy loader function.
- */
-export interface ContractSourceLoader {
-  readonly kind: 'loader';
-  readonly load: () => unknown | Promise<unknown>;
-}
-
-/**
- * Discriminated union for contract source.
- * Use `kind` to determine how to resolve the contract.
- */
-export type EmitContractSource = ContractSourceValue | ContractSourceLoader;
-
 /**
  * Contract configuration for emit operation.
  */
 export interface EmitContractConfig {
   /**
-   * Contract source - either a raw value or a loader function.
-   * Switch on `source.kind` to determine how to resolve.
+   * Contract source provider.
    */
-  readonly source: EmitContractSource;
+  readonly sourceProvider: ContractSourceProvider;
   /**
    * Output path for contract.json.
    * The .d.ts types file will be colocated (e.g., contract.json → contract.d.ts).
@@ -340,6 +321,7 @@ export interface EmitFailure {
   readonly summary: string;
   readonly why: string | undefined;
   readonly meta: Record<string, unknown> | undefined;
+  readonly diagnostics?: ContractSourceDiagnostics;
 }
 
 /**

package/src/exports/control-api.ts

@@ -25,8 +25,6 @@ export { executeContractEmit } from '../control-api/operations/contract-emit';
 export type {
   ContractEmitOptions,
   ContractEmitResult,
-  ContractSourceLoader,
-  ContractSourceValue,
   ControlActionName,
   ControlClient,
   ControlClientOptions,
@@ -37,7 +35,6 @@ export type {
   DbInitResult,
   DbInitSuccess,
   EmitContractConfig,
-  EmitContractSource,
   EmitFailure,
   EmitFailureCode,
   EmitOptions,