@prisma-next/sql-contract-ts 0.16.0-dev.3 → 0.16.0-dev.31

package/src/contract-builder.ts

@@ -33,6 +33,7 @@ import {
   type ScalarFieldBuilder,
   type SqlStageSpec,
 } from './contract-dsl';
+import { contractError } from './contract-errors';
 import { buildContractDefinition } from './contract-lowering';
 import type { SqlContractResult } from './contract-types';
 import type { EnumTypeHandle } from './enum-type';
@@ -57,7 +58,7 @@ type ContractDefinition<
   Target extends TargetPackRef<'sql', string>,
   Types extends Record<string, StorageTypeInstance>,
   Models extends Record<string, ModelLike>,
-  ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
@@ -66,7 +67,7 @@ type ContractDefinition<
 > = {
   readonly family: Family;
   readonly target: Target;
-  readonly extensionPacks?: ExtensionPacks;
+  readonly extensions?: Extensions;
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
@@ -83,7 +84,7 @@ type ContractDefinition<
 type ContractScaffold<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
-  ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
@@ -92,7 +93,7 @@ type ContractScaffold<
 > = {
   readonly family: Family;
   readonly target: Target;
-  readonly extensionPacks?: ExtensionPacks;
+  readonly extensions?: Extensions;
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
@@ -111,9 +112,9 @@ type ContractFactory<
   Target extends TargetPackRef<'sql', string>,
   Types extends Record<string, StorageTypeInstance>,
   Models extends Record<string, ModelLike>,
-  ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
   Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
-> = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
+> = (helpers: ComposedAuthoringHelpers<Family, Target, Extensions>) => {
   readonly types?: Types;
   readonly models?: Models;
   readonly enums?: Enums;
@@ -125,14 +126,24 @@ function validateTargetPackRef(
   target: TargetPackRef<'sql', string>,
 ): void {
   if (family.familyId !== 'sql') {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.PACK_FAMILY_MISMATCH',
       `defineContract only accepts SQL family packs. Received family "${family.familyId}".`,
+      { meta: { packId: family.id, packFamilyId: family.familyId, contractFamilyId: 'sql' } },
     );
   }
 
   if (target.familyId !== family.familyId) {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.PACK_FAMILY_MISMATCH',
       `target pack "${target.id}" targets family "${target.familyId}" but contract family is "${family.familyId}".`,
+      {
+        meta: {
+          packId: target.id,
+          packFamilyId: target.familyId,
+          contractFamilyId: family.familyId,
+        },
+      },
     );
   }
 }
@@ -161,33 +172,51 @@ function validateNamespaceDeclarations(
   }
 
   if (target.targetId === 'sqlite' && namespaces.length > 0) {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.NAMESPACE_UNSUPPORTED',
       `defineContract: SQLite contracts cannot declare namespaces (SQLite has no schema concept; emitted DDL is always unqualified). Received namespaces: [${namespaces
         .map((name) => `"${name}"`)
         .join(', ')}].`,
+      { meta: { namespaces, targetId: target.targetId } },
     );
   }
 
   const seen = new Set<string>();
   for (const namespace of namespaces) {
     if (namespace.length === 0) {
-      throw new Error('defineContract: namespace names cannot be empty.');
+      throw contractError(
+        'CONTRACT.NAMESPACE_INVALID',
+        'defineContract: namespace names cannot be empty.',
+        { meta: { namespace, reason: 'empty' } },
+      );
     }
     if (namespace.trim().length === 0) {
-      throw new Error(`defineContract: namespace name "${namespace}" cannot be whitespace-only.`);
+      throw contractError(
+        'CONTRACT.NAMESPACE_INVALID',
+        `defineContract: namespace name "${namespace}" cannot be whitespace-only.`,
+        { meta: { namespace, reason: 'whitespace-only' } },
+      );
     }
     if (namespace === '__unbound__' || namespace === '__unspecified__') {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAMESPACE_INVALID',
         `defineContract: namespace name "${namespace}" is a reserved IR sentinel and cannot appear in the declared namespaces list.`,
+        { meta: { namespace, reason: 'reserved-ir-sentinel' } },
       );
     }
     if (target.targetId === 'postgres' && namespace === 'unbound') {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAMESPACE_INVALID',
         `defineContract: namespace name "unbound" is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead of declaring it as a regular schema).`,
+        { meta: { namespace, reason: 'reserved-by-postgres' } },
       );
     }
     if (seen.has(namespace)) {
-      throw new Error(`defineContract: namespaces list contains duplicate entry "${namespace}".`);
+      throw contractError(
+        'CONTRACT.NAME_DUPLICATE',
+        `defineContract: namespaces list contains duplicate entry "${namespace}".`,
+        { meta: { kind: 'namespace', name: namespace } },
+      );
     }
     seen.add(namespace);
   }
@@ -228,20 +257,26 @@ function validatePerModelNamespaces(
     }
 
     if (target.targetId === 'sqlite') {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAMESPACE_UNSUPPORTED',
         `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but the target is SQLite (SQLite has no schema concept; remove the per-model \`namespace\` field).`,
+        { meta: { modelKey, namespace: perModelNamespace, targetId: target.targetId } },
       );
     }
 
     if (perModelNamespace === '__unbound__' || perModelNamespace === '__unspecified__') {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAMESPACE_INVALID',
         `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but that name is a reserved IR sentinel and cannot appear in user code.`,
+        { meta: { modelKey, namespace: perModelNamespace, reason: 'reserved-ir-sentinel' } },
       );
     }
 
     if (target.targetId === 'postgres' && perModelNamespace === 'unbound') {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAMESPACE_INVALID',
         `defineContract: model "${modelKey}" sets \`namespace: "unbound"\` but that name is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead — there is no equivalent surface in the TS builder today).`,
+        { meta: { modelKey, namespace: perModelNamespace, reason: 'reserved-by-postgres' } },
       );
     }
 
@@ -250,8 +285,10 @@ function validatePerModelNamespaces(
         declaredNamespaces.size > 0
           ? ` Declared namespaces: [${[...declaredNamespaces].map((name) => `"${name}"`).join(', ')}].`
           : ' The contract does not declare any namespaces; add `namespaces: ["…"]` to `defineContract` first.';
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAMESPACE_UNKNOWN',
         `defineContract: model "${modelKey}" references namespace "${perModelNamespace}" but that name does not appear in the contract's declared \`namespaces\` list.${hint}`,
+        { meta: { modelKey, namespace: perModelNamespace, declared: [...declaredNamespaces] } },
       );
     }
   }
@@ -259,28 +296,46 @@ function validatePerModelNamespaces(
 
 function validateExtensionPackRefs(
   target: TargetPackRef<'sql', string>,
-  extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
+  extensions?: Record<string, ExtensionPackRef<'sql', string>>,
 ): void {
-  if (!extensionPacks) {
+  if (!extensions) {
     return;
   }
 
-  for (const packRef of Object.values(extensionPacks)) {
+  for (const packRef of Object.values(extensions)) {
     if (packRef.kind !== 'extension') {
-      throw new Error(
-        `defineContract only accepts extension pack refs in extensionPacks. Received kind "${packRef.kind}".`,
+      throw contractError(
+        'CONTRACT.PACK_REF_INVALID',
+        `defineContract only accepts extension pack refs in extensions. Received kind "${packRef.kind}".`,
+        { meta: { packId: packRef.id, kind: packRef.kind } },
       );
     }
 
     if (packRef.familyId !== target.familyId) {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.PACK_FAMILY_MISMATCH',
         `extension pack "${packRef.id}" targets family "${packRef.familyId}" but contract target family is "${target.familyId}".`,
+        {
+          meta: {
+            packId: packRef.id,
+            packFamilyId: packRef.familyId,
+            contractFamilyId: target.familyId,
+          },
+        },
       );
     }
 
     if (packRef.targetId && packRef.targetId !== target.targetId) {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.PACK_TARGET_MISMATCH',
         `extension pack "${packRef.id}" targets "${packRef.targetId}" but contract target is "${target.targetId}".`,
+        {
+          meta: {
+            packId: packRef.id,
+            packTargetId: packRef.targetId,
+            contractTargetId: target.targetId,
+          },
+        },
       );
     }
   }
@@ -290,7 +345,7 @@ function buildContractFromDsl<Definition extends ContractInput>(
   definition: Definition,
 ): SqlContractResult<Definition> {
   validateTargetPackRef(definition.family, definition.target);
-  validateExtensionPackRefs(definition.target, definition.extensionPacks);
+  validateExtensionPackRefs(definition.target, definition.extensions);
   validateNamespaceDeclarations(definition.target, definition.namespaces);
   validatePerModelNamespaces(
     definition.target,
@@ -309,13 +364,13 @@ function buildContractFromDsl<Definition extends ContractInput>(
 type BoundDefinitionInput<
   Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   Models extends Record<string, ModelLike> = Record<never, never>,
-  ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
+  Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
   Naming extends ContractInput['naming'] | undefined = undefined,
   StorageHash extends string | undefined = undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   Namespaces extends readonly string[] | undefined = undefined,
 > = {
-  readonly extensionPacks?: ExtensionPacks;
+  readonly extensions?: Extensions;
   readonly naming?: Naming;
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
@@ -402,7 +457,7 @@ export function buildBoundContract<
   target: T,
   definition: Definition,
   factory: (
-    helpers: ComposedAuthoringHelpers<F, T, NonNullable<Definition['extensionPacks']>>,
+    helpers: ComposedAuthoringHelpers<F, T, NonNullable<Definition['extensions']>>,
   ) => Built,
 ): SqlContractResult<WithFamilyTarget<Definition & Built, F, T>>;
 /** Implementation. */
@@ -432,7 +487,7 @@ export function buildBoundContract(
       createComposedAuthoringHelpers({
         family,
         target,
-        extensionPacks: definition.extensionPacks,
+        extensions: definition.extensions,
       }),
     );
     const mergedEnums = { ...(definition.enums ?? {}), ...built.enums };
@@ -454,9 +509,7 @@ export function defineContract<
   const Target extends TargetPackRef<'sql', string>,
   const Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   const Models extends Record<string, ModelLike> = Record<never, never>,
-  const ExtensionPacks extends
-    | Record<string, ExtensionPackRef<'sql', string>>
-    | undefined = undefined,
+  const Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
   const Naming extends ContractInput['naming'] | undefined = undefined,
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
@@ -468,7 +521,7 @@ export function defineContract<
     Target,
     Types,
     Models,
-    ExtensionPacks,
+    Extensions,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
@@ -481,7 +534,7 @@ export function defineContract<
     Target,
     Types,
     Models,
-    ExtensionPacks,
+    Extensions,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
@@ -494,9 +547,7 @@ export function defineContract<
   const Target extends TargetPackRef<'sql', string>,
   const Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   const Models extends Record<string, ModelLike> = Record<never, never>,
-  const ExtensionPacks extends
-    | Record<string, ExtensionPackRef<'sql', string>>
-    | undefined = undefined,
+  const Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
   const Naming extends ContractInput['naming'] | undefined = undefined,
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
@@ -507,21 +558,21 @@ export function defineContract<
   definition: ContractScaffold<
     Family,
     Target,
-    ExtensionPacks,
+    Extensions,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
     Namespaces,
     ScaffoldEnums
   >,
-  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks, FactoryEnums>,
+  factory: ContractFactory<Family, Target, Types, Models, Extensions, FactoryEnums>,
 ): SqlContractResult<
   ContractDefinition<
     Family,
     Target,
     Types,
     Models,
-    ExtensionPacks,
+    Extensions,
     Naming,
     StorageHash,
     ForeignKeyDefaults,
@@ -540,7 +591,8 @@ export function defineContract(
   >,
 ): SqlContractResult<ContractInput> {
   if (!isContractInput(definition)) {
-    throw new TypeError(
+    throw contractError(
+      'CONTRACT.ARGUMENT_INVALID',
       'defineContract expects a contract definition object. Define your contract with defineContract({ family, target, models, ... }).',
     );
   }

package/src/contract-definition.ts

@@ -57,6 +57,9 @@ export interface UniqueConstraintNode {
 
 export interface IndexNode {
   readonly columns: readonly string[];
+  /** Exact physical name (PSL `map:`) — adopted verbatim, no wire hash. */
+  readonly map?: string;
+  /** Managed wire-name prefix (TS `name:`) — lowers to `<name>_<8hex>`. */
   readonly name?: string;
   readonly type?: string;
   readonly options?: Record<string, unknown>;
@@ -183,7 +186,7 @@ export interface ModelNode {
 export interface ContractDefinition {
   readonly target: TargetPackRef<'sql', string>;
   readonly defaultControlPolicy?: ControlPolicy;
-  readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
+  readonly extensions?: Record<string, ExtensionPackRef<'sql', string>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
   readonly storageTypes?: Record<string, StorageTypeInstance>;

package/src/contract-dsl.ts

@@ -23,6 +23,7 @@ import type {
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { NamedConstraintSpec } from './authoring-type-utils';
+import { contractError } from './contract-errors';
 import type { EnumTypeHandle } from './enum-type';
 import { isEnumTypeHandle } from './enum-type';
 
@@ -402,10 +403,14 @@ export class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFie
     const uniqueSpec = 'unique' in spec ? spec.unique : undefined;
 
     if (idSpec && !this.state.id) {
-      throw new Error('field.sql({ id }) requires an existing inline .id(...) declaration.');
+      throw contractError(
+        'CONTRACT.ARGUMENT_INVALID',
+        'field.sql({ id }) requires an existing inline .id(...) declaration.',
+      );
     }
     if (uniqueSpec && !this.state.unique) {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.ARGUMENT_INVALID',
         'field.sql({ unique }) requires an existing inline .unique(...) declaration.',
       );
     }
@@ -457,8 +462,10 @@ export class EnumScalarFieldBuilder<
   }
 
   override defaultSql(_expression: never): never {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.DEFAULT_INVALID',
       'defaultSql is not available on an enum field; use .default(members.X) instead',
+      { meta: { reason: 'defaultSql-on-enum-field' } },
     );
   }
 }
@@ -674,7 +681,11 @@ export class RelationBuilder<State extends RelationState = AnyRelationState> {
     spec: SqlSpec,
   ): RelationBuilder<ApplyBelongsToRelationSqlSpec<State, SqlSpec>> {
     if (this.state.kind !== 'belongsTo') {
-      throw new Error('relation.sql(...) is only supported for belongsTo relations.');
+      throw contractError(
+        'CONTRACT.RELATION_INVALID',
+        'relation.sql(...) is only supported for belongsTo relations.',
+        { meta: { relationKind: this.state.kind } },
+      );
     }
 
     return new RelationBuilder({
@@ -860,27 +871,45 @@ function normalizeTargetFieldRefInput(input: TargetFieldRef | readonly TargetFie
   const refs = Array.isArray(input) ? input : [input];
   const [first] = refs;
   if (!first) {
-    throw new Error('Expected at least one target ref');
+    throw contractError('CONTRACT.FOREIGN_KEY_INVALID', 'Expected at least one target ref', {
+      meta: { reason: 'empty-target-refs' },
+    });
   }
   if (refs.some((ref) => ref.modelName !== first.modelName)) {
-    throw new Error('All target refs in a foreign key must point to the same model');
+    throw contractError(
+      'CONTRACT.FOREIGN_KEY_INVALID',
+      'All target refs in a foreign key must point to the same model',
+      { meta: { mismatch: 'modelName', models: refs.map((ref) => ref.modelName) } },
+    );
   }
   // F-compound: all refs in a compound FK must share the same cross-space coordinate.
   // A mismatch in spaceId, namespaceId, or tableName means the refs come from
   // different spaces despite having the same modelName — an impossible FK.
   if (refs.some((ref) => ref.spaceId !== first.spaceId)) {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.FOREIGN_KEY_INVALID',
       `All target refs in a compound foreign key must share the same spaceId (found mismatch: "${first.spaceId ?? '<local>'}" vs "${refs.find((r) => r.spaceId !== first.spaceId)?.spaceId ?? '<local>'}")`,
+      {
+        meta: {
+          mismatch: 'spaceId',
+          first: first.spaceId,
+          second: refs.find((r) => r.spaceId !== first.spaceId)?.spaceId,
+        },
+      },
     );
   }
   if (refs.some((ref) => ref.namespaceId !== first.namespaceId)) {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.FOREIGN_KEY_INVALID',
       'All target refs in a compound foreign key must share the same namespaceId (found mismatch)',
+      { meta: { mismatch: 'namespaceId' } },
     );
   }
   if (refs.some((ref) => ref.tableName !== first.tableName)) {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.FOREIGN_KEY_INVALID',
       'All target refs in a compound foreign key must share the same tableName (found mismatch)',
+      { meta: { mismatch: 'tableName' } },
     );
   }
   return {
@@ -1322,7 +1351,10 @@ export class ContractModelBuilder<
   ): TargetFieldRef<ModelName & string, FieldName> {
     const modelName = this.stageOne.modelName;
     if (!modelName) {
-      throw new Error('Model tokens require model("ModelName", ...) before calling .ref(...)');
+      throw contractError(
+        'CONTRACT.MODEL_TOKEN_INVALID',
+        'Model tokens require model("ModelName", ...) before calling .ref(...)',
+      );
     }
 
     return {
@@ -1346,8 +1378,16 @@ export class ContractModelBuilder<
   > {
     const duplicateRelationName = findDuplicateRelationName(this.stageOne.relations, relations);
     if (duplicateRelationName) {
-      throw new Error(
+      throw contractError(
+        'CONTRACT.NAME_DUPLICATE',
         `Model "${this.stageOne.modelName ?? '<anonymous>'}" already defines relation "${duplicateRelationName}".`,
+        {
+          meta: {
+            kind: 'relation',
+            name: duplicateRelationName,
+            modelName: this.stageOne.modelName,
+          },
+        },
       );
     }
 
@@ -1501,7 +1541,8 @@ function resolveNamedModelTokenName(token: {
 }): string {
   const modelName = token.stageOne.modelName;
   if (!modelName) {
-    throw new Error(
+    throw contractError(
+      'CONTRACT.MODEL_TOKEN_INVALID',
       'Relation targets require named model tokens. Use model("ModelName", ...) before passing a token to rel.*(...).',
     );
   }
@@ -1557,11 +1598,11 @@ export type ContractInput<
       SqlStageSpec | undefined
     >
   > = Record<never, never>,
-  ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
+  Extensions extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
 > = {
   readonly family: Family;
   readonly target: Target;
-  readonly extensionPacks?: ExtensionPacks;
+  readonly extensions?: Extensions;
   readonly naming?: NamingConfig;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
@@ -1668,7 +1709,10 @@ export function model<
   const input = typeof modelNameOrInput === 'string' ? maybeInput : modelNameOrInput;
 
   if (!input) {
-    throw new Error('model("ModelName", ...) requires a model definition.');
+    throw contractError(
+      'CONTRACT.ARGUMENT_INVALID',
+      'model("ModelName", ...) requires a model definition.',
+    );
   }
 
   return new ContractModelBuilder({

package/src/contract-errors.ts

@@ -0,0 +1,39 @@
+import type { StructuredError, StructuredErrorOptions } from '@prisma-next/utils/structured-error';
+import { structuredError } from '@prisma-next/utils/structured-error';
+
+export type ContractCode = `CONTRACT.${ContractSubcode}`;
+
+type ContractSubcode =
+  | 'VALIDATION_FAILED'
+  | 'NAME_DUPLICATE'
+  | 'MODEL_UNKNOWN'
+  | 'PACK_CONTRIBUTION_INVALID'
+  | 'PACK_FAMILY_MISMATCH'
+  | 'PACK_TARGET_MISMATCH'
+  | 'PACK_REF_INVALID'
+  | 'PACK_MISSING'
+  | 'NAMESPACE_INVALID'
+  | 'NAMESPACE_UNSUPPORTED'
+  | 'NAMESPACE_UNKNOWN'
+  | 'ARGUMENT_INVALID'
+  | 'FOREIGN_KEY_INVALID'
+  | 'RELATION_INVALID'
+  | 'IDENTITY_INVALID'
+  | 'CONSTRAINT_INVALID'
+  | 'DEFAULT_INVALID'
+  | 'ENUM_INVALID'
+  | 'TYPE_UNKNOWN'
+  | 'FIELD_UNKNOWN'
+  | 'MODEL_TOKEN_INVALID'
+  | 'MODULE_EXPORT_MISSING'
+  | 'ENTITY_KIND_UNKNOWN'
+  | 'ENTITY_KIND_INVALID'
+  | 'TABLE_MISMATCH';
+
+export function contractError(
+  code: ContractCode,
+  message: string,
+  options?: StructuredErrorOptions,
+): StructuredError {
+  return structuredError(code, message, options);
+}