@prisma-next/sql-contract-ts 0.14.0-dev.7 → 0.14.0-dev.71

package/src/composed-authoring-helpers.ts

@@ -13,9 +13,6 @@ import type {
 } from '@prisma-next/framework-components/authoring';
 import {
   assertNoCrossRegistryCollisions,
-  isAuthoringEntityTypeDescriptor,
-  isAuthoringFieldPresetDescriptor,
-  isAuthoringTypeConstructorDescriptor,
   mergeAuthoringNamespaces,
 } from '@prisma-next/framework-components/authoring';
 import type {
@@ -183,7 +180,7 @@ function composeTypeNamespace(components: readonly AuthoringComponent[]): Author
   for (const component of components) {
     const ns = extractTypeNamespace(component);
     if (Object.keys(ns).length > 0) {
-      mergeAuthoringNamespaces(merged, ns, [], isAuthoringTypeConstructorDescriptor, 'type');
+      mergeAuthoringNamespaces(merged, ns, [], 'typeConstructor', 'type');
     }
   }
   return merged as AuthoringTypeNamespace;
@@ -194,7 +191,7 @@ function composeFieldNamespace(components: readonly AuthoringComponent[]): Autho
   for (const component of components) {
     const ns = extractFieldNamespace(component);
     if (Object.keys(ns).length > 0) {
-      mergeAuthoringNamespaces(merged, ns, [], isAuthoringFieldPresetDescriptor, 'field');
+      mergeAuthoringNamespaces(merged, ns, [], 'fieldPreset', 'field');
     }
   }
   return merged as AuthoringFieldNamespace;
@@ -207,7 +204,7 @@ function composeEntityNamespace(
   for (const component of components) {
     const ns = extractEntitiesNamespace(component);
     if (Object.keys(ns).length > 0) {
-      mergeAuthoringNamespaces(merged, ns, [], isAuthoringEntityTypeDescriptor, 'entity');
+      mergeAuthoringNamespaces(merged, ns, [], 'entity', 'entity');
     }
   }
   return merged as AuthoringEntityTypeNamespace;

package/src/config-types.ts

@@ -3,6 +3,7 @@ import type { ContractConfig } from '@prisma-next/config/config-types';
 import { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';
 import type { Contract, ControlPolicy } from '@prisma-next/contract/types';
 import type { TargetPackRef } from '@prisma-next/framework-components/components';
+import type { SqlNamespaceBase, SqlNamespaceInput } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { ok } from '@prisma-next/utils/result';
 import { extname } from 'pathe';
@@ -27,13 +28,18 @@ export interface TypeScriptContractSpecifierOptions {
 export function emptyContract(options: {
   readonly output?: string;
   readonly target: TargetPackRef<'sql', string>;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly defaultControlPolicy?: ControlPolicy;
 }): ContractConfig {
   return {
     source: {
       sourceFormat: 'typescript',
       load: async () => {
-        const built = buildSqlContractFromDefinition({ target: options.target, models: [] });
+        const built = buildSqlContractFromDefinition({
+          target: options.target,
+          createNamespace: options.createNamespace,
+          models: [],
+        });
         return ok(applySpecifierDefaultControlPolicy(built, options.defaultControlPolicy));
       },
     },

package/src/contract-builder.ts

@@ -6,8 +6,11 @@ import type {
   FamilyPackRef,
   TargetPackRef,
 } from '@prisma-next/framework-components/components';
-import type { Namespace } from '@prisma-next/framework-components/ir';
-import type { SqlNamespaceTablesInput, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import type {
+  SqlNamespaceBase,
+  SqlNamespaceInput,
+  StorageTypeInstance,
+} from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { buildSqlContractFromDefinition } from './build-contract';
@@ -15,6 +18,7 @@ import {
   type ComposedAuthoringHelpers,
   createComposedAuthoringHelpers,
 } from './composed-authoring-helpers';
+import type { PackEntitiesInput } from './contract-definition';
 import {
   type ContractInput,
   type ContractModelBuilder,
@@ -68,11 +72,12 @@ type ContractDefinition<
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
   readonly enums?: Enums;
+  readonly packEntities?: PackEntitiesInput;
 };
 
 type ContractScaffold<
@@ -93,11 +98,12 @@ type ContractScaffold<
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
   readonly enums?: Enums;
+  readonly packEntities?: PackEntitiesInput;
 };
 
 type ContractFactory<
@@ -111,6 +117,7 @@ type ContractFactory<
   readonly types?: Types;
   readonly models?: Models;
   readonly enums?: Enums;
+  readonly packEntities?: PackEntitiesInput;
 };
 
 function validateTargetPackRef(
@@ -314,11 +321,12 @@ type BoundDefinitionInput<
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly defaultControlPolicy?: ControlPolicy;
   readonly namespaces?: Namespaces;
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
   readonly enums?: Record<string, EnumTypeHandle>;
+  readonly packEntities?: PackEntitiesInput;
 };
 
 // A bare `Record<string, EnumTypeHandle>` (no literal keys) is the widened
@@ -342,6 +350,60 @@ type WithFamilyTarget<
   T extends TargetPackRef<'sql', string>,
 > = Input & { readonly family: F; readonly target: T };
 
+// Deep-merges packEntities authored on the scaffold definition with those
+// returned from the factory callback — three levels deep (namespace, kind,
+// name), unlike `enums`' flat shallow merge, since a factory-declared
+// namespace/kind must not silently drop a scaffold-declared sibling entry
+// under the same namespace or kind. A same-name key present on both sides is
+// only merged when it is the identical entity instance; two *different*
+// entities of the same namespace/kind/name is a collision (the emitted
+// entry could reflect only one), rejected here the same way
+// `mergeCollectedPackEntities` in `build-contract.ts` rejects it.
+function mergePackEntityNames(
+  namespaceId: string,
+  kind: string,
+  a: Readonly<Record<string, unknown>> | undefined,
+  b: Readonly<Record<string, unknown>> | undefined,
+): Readonly<Record<string, unknown>> {
+  if (a !== undefined && b !== undefined) {
+    for (const [name, entity] of Object.entries(b)) {
+      const existing = a[name];
+      if (existing !== undefined && existing !== entity) {
+        throw new Error(
+          `defineContract: two different "${kind}" entities named "${name}" in namespace "${namespaceId}" — a factory-returned pack entity conflicts with a scaffold-declared one; pack-entity names must be unique per namespace.`,
+        );
+      }
+    }
+  }
+  return { ...(a ?? {}), ...(b ?? {}) };
+}
+
+function mergePackEntityKinds(
+  namespaceId: string,
+  a: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined,
+  b: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined,
+): Readonly<Record<string, Readonly<Record<string, unknown>>>> {
+  const kinds = new Set([...Object.keys(a ?? {}), ...Object.keys(b ?? {})]);
+  const result: Record<string, Readonly<Record<string, unknown>>> = {};
+  for (const kind of kinds) {
+    result[kind] = mergePackEntityNames(namespaceId, kind, a?.[kind], b?.[kind]);
+  }
+  return result;
+}
+
+function mergePackEntities(
+  a: PackEntitiesInput | undefined,
+  b: PackEntitiesInput | undefined,
+): PackEntitiesInput | undefined {
+  if (a === undefined && b === undefined) return undefined;
+  const namespaces = new Set([...Object.keys(a ?? {}), ...Object.keys(b ?? {})]);
+  const result: Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>> = {};
+  for (const namespaceId of namespaces) {
+    result[namespaceId] = mergePackEntityKinds(namespaceId, a?.[namespaceId], b?.[namespaceId]);
+  }
+  return result;
+}
+
 /**
  * Shared builder that assembles a SqlContract with pre-bound family and target.
  * Extension wrappers keep their own public overloads and delegate their impl body here;
@@ -387,6 +449,7 @@ export function buildBoundContract<
     readonly types?: Record<string, StorageTypeInstance>;
     readonly models?: Record<string, ModelLike>;
     readonly enums?: Record<string, EnumTypeHandle>;
+    readonly packEntities?: PackEntitiesInput;
   },
 >(
   family: F,
@@ -412,6 +475,7 @@ export function buildBoundContract(
         readonly types?: Record<string, StorageTypeInstance>;
         readonly models?: Record<string, ModelLike>;
         readonly enums?: Record<string, EnumTypeHandle>;
+        readonly packEntities?: PackEntitiesInput;
       })
     | undefined,
 ) {
@@ -426,11 +490,13 @@ export function buildBoundContract(
       }),
     );
     const mergedEnums = { ...(definition.enums ?? {}), ...built.enums };
+    const mergedPackEntities = mergePackEntities(definition.packEntities, built.packEntities);
     return buildContractFromDsl({
       ...full,
       ...ifDefined('types', built.types),
       ...ifDefined('models', built.models),
       ...ifDefined('enums', Object.keys(mergedEnums).length > 0 ? mergedEnums : undefined),
+      ...ifDefined('packEntities', mergedPackEntities),
     });
   }
 

package/src/contract-definition.ts

@@ -6,16 +6,30 @@ import type {
 import type { ForeignKeyDefaultsState } from '@prisma-next/contract-authoring';
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
-import type { Namespace } from '@prisma-next/framework-components/ir';
 import type {
   ReferentialAction,
-  SqlNamespaceTablesInput,
+  SqlNamespaceBase,
+  SqlNamespaceInput,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import type { EnumTypeHandle } from './enum-type';
 
 export type { ExecutionMutationDefaultPhases };
 
+/**
+ * An author-declared, namespace-scoped pack entity attachment: namespace id →
+ * entity kind (the discriminator the target/extension pack registered its
+ * `AuthoringContributions.entityTypes` descriptor under, e.g. `native_enum`)
+ * → entity name → the lowered entity instance. Generic on purpose — neither
+ * the framework nor `contract-ts` names a specific entity kind here; the
+ * shape mirrors `SqlNamespaceInput.entries` (`entries.<kind>[name]`), just
+ * namespace-nested so an author can target any declared namespace (default
+ * or named), not only the contract's default namespace.
+ */
+export type PackEntitiesInput = Readonly<
+  Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>
+>;
+
 export interface FieldNode {
   readonly fieldName: string;
   readonly columnName: string;
@@ -175,8 +189,8 @@ export interface ContractDefinition {
    * `SqlStorage.namespaces` together with `createNamespace`.
    */
   readonly namespaces?: readonly string[];
-  /** Target-supplied factory that materialises a `Namespace` concretion for a declared namespace coordinate. */
-  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  /** Target-supplied factory that materialises a `SqlNamespaceBase` concretion for a declared namespace coordinate. */
+  readonly createNamespace: (input: SqlNamespaceInput) => SqlNamespaceBase;
   readonly models: readonly ModelNode[];
   readonly valueObjects?: readonly ValueObjectNode[];
   /**
@@ -185,4 +199,13 @@ export interface ContractDefinition {
    * default namespace.
    */
   readonly enums?: Record<string, EnumTypeHandle>;
+  /**
+   * Author-declared pack entities, keyed by namespace then entity kind then
+   * name. Each entity lowers into `storage.namespaces[ns].entries.<kind>`;
+   * when the registered entity-type descriptor's factory output implements
+   * the `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook, the
+   * derived value-set also folds into `entries.valueSet`, mirroring how
+   * `enums` flows there.
+   */
+  readonly packEntities?: PackEntitiesInput;
 }