@prisma-next/contract-authoring 0.7.0-dev.7 → 0.8.0-dev.1

package/dist/index.d.mts

@@ -1,3 +1,59 @@
+import { AuthoringEntityContext, AuthoringEntityTypeDescriptor, AuthoringEntityTypeNamespace } from "@prisma-next/framework-components/authoring";
+
+//#region src/composed-helpers-scaffolding.d.ts
+/**
+ * Family-agnostic merge / instantiation scaffolding for pack-bag-driven
+ * authoring contributions. The per-namespace shape (`field`, `type`,
+ * `entityTypes`) is parameterized by the discriminator key so each
+ * namespace can reuse the same extractor + cross-pack merger without
+ * re-deriving the template per family. Call sites flatten merged
+ * `entityTypes` onto the user-facing top-level helpers surface
+ * alongside the built-in `model` / `rel` (e.g. `helpers.enum(...)`).
+ * The contribution data structure stays as
+ * `authoring.entityTypes.<name>` — pack authors keep contributing
+ * through the namespace; the composed-helpers template performs the
+ * rename in the type system.
+ *
+ * SQL-specific composition (the `field` / `model` / `rel` / `type` core
+ * helpers, the SQL index-types merge) lives in the SQL contract-ts
+ * package and imports from here.
+ */
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends ((value: infer I) => void) ? I : never;
+type AuthoringNamespaceKey = 'field' | 'type' | 'entityTypes';
+type ExtractAuthoringNamespaceFromPack<Pack, Key extends AuthoringNamespaceKey, EmptyNamespace> = Pack extends {
+  readonly authoring?: { readonly [P in Key]?: infer Namespace };
+} ? Namespace extends Record<string, unknown> ? Namespace : EmptyNamespace : EmptyNamespace;
+type MergeExtensionAuthoringNamespaces<ExtensionPacks, Key extends AuthoringNamespaceKey, EmptyNamespace = Record<never, never>> = ExtensionPacks extends Record<string, unknown> ? keyof ExtensionPacks extends never ? EmptyNamespace : UnionToIntersection<{ [K in keyof ExtensionPacks]: ExtractAuthoringNamespaceFromPack<ExtensionPacks[K], Key, EmptyNamespace> }[keyof ExtensionPacks]> : EmptyNamespace;
+/**
+ * Entity-helper shape derivation. Mirrors `FieldHelpersFromNamespace` /
+ * `TypeHelpersFromNamespace` in the SQL package: leaf descriptors become
+ * callable helpers; nested namespaces recurse.
+ */
+type ExtractFactoryInputAndOutput<Descriptor extends AuthoringEntityTypeDescriptor> = Descriptor['output'] extends {
+  readonly factory: (input: infer Input, ctx: AuthoringEntityContext) => infer Output;
+} ? {
+  input: Input;
+  output: Output;
+} : {
+  input: unknown;
+  output: unknown;
+};
+type EntityHelperFunction<Descriptor extends AuthoringEntityTypeDescriptor> = ExtractFactoryInputAndOutput<Descriptor> extends {
+  input: infer Input;
+  output: infer Output;
+} ? (input: Input) => Output : never;
+type EntityHelpersFromNamespace<Namespace> = { readonly [K in keyof Namespace]: Namespace[K] extends AuthoringEntityTypeDescriptor ? EntityHelperFunction<Namespace[K]> : Namespace[K] extends Record<string, unknown> ? EntityHelpersFromNamespace<Namespace[K]> : never };
+interface EntityHelperFactoryOptions {
+  readonly ctx: AuthoringEntityContext;
+}
+/**
+ * Walks an entity-type namespace (after cross-pack merge) and produces the
+ * runtime callable surface mirroring its tree shape. Each leaf
+ * descriptor becomes a function `(input) => factory(input, ctx)`;
+ * nested namespace objects recurse.
+ */
+declare function createEntityHelpersFromNamespace(namespace: AuthoringEntityTypeNamespace, options: EntityHelperFactoryOptions, path?: readonly string[]): Record<string, unknown>;
+//#endregion
 //#region src/descriptors.d.ts
 interface IndexDef {
   readonly columns: readonly string[];
@@ -10,5 +66,5 @@ interface ForeignKeyDefaultsState {
   readonly index: boolean;
 }
 //#endregion
-export { type ForeignKeyDefaultsState, type IndexDef };
+export { type AuthoringNamespaceKey, type EntityHelperFactoryOptions, type EntityHelperFunction, type EntityHelpersFromNamespace, type ExtractAuthoringNamespaceFromPack, type ForeignKeyDefaultsState, type IndexDef, type MergeExtensionAuthoringNamespaces, type UnionToIntersection, createEntityHelpersFromNamespace };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/descriptors.ts"],"mappings":";UAAiB,QAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,GAAU,MAAA;AAAA;AAAA,UAGJ,uBAAA;EAAA,SACN,UAAA;EAAA,SACA,KAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/composed-helpers-scaffolding.ts","../src/descriptors.ts"],"mappings":";;;;;AAyBA;;;;;;;;;;;;;AAMA;;KANY,mBAAA,OAA0B,CAAA,oBAAqB,KAAA,EAAO,CAAA,6BAChE,KAAA,sBAEE,CAAA;AAAA,KAGQ,qBAAA;AAAA,KAEA,iCAAA,mBAEE,qBAAA,oBAEV,IAAA;EAAA,SACO,SAAA,oBAA6B,GAAA;AAAA,IAEpC,SAAA,SAAkB,MAAA,oBAChB,SAAA,GACA,cAAA,GACF,cAAA;AAAA,KAEQ,iCAAA,6BAEE,qBAAA,mBACK,MAAA,kBAEjB,cAAA,SAAuB,MAAA,0BACb,cAAA,iBACJ,cAAA,GACA,mBAAA,eAEgB,cAAA,GAAiB,iCAAA,CAC3B,cAAA,CAAe,CAAA,GACf,GAAA,EACA,cAAA,UAEI,cAAA,KAEZ,cAAA;;;;;;KAOD,4BAAA,oBAAgD,6BAAA,IACnD,UAAA;EAAA,SACW,OAAA,GAAU,KAAA,eAAoB,GAAA,EAAK,sBAAA;AAAA;EAExC,KAAA,EAAO,KAAA;EAAO,MAAA,EAAQ,MAAA;AAAA;EACtB,KAAA;EAAgB,MAAA;AAAA;AAAA,KAEZ,oBAAA,oBAAwC,6BAAA,IAClD,4BAAA,CAA6B,UAAA;EAAsB,KAAA;EAAoB,MAAA;AAAA,KAClE,KAAA,EAAO,KAAA,KAAU,MAAA;AAAA,KAGZ,0BAAA,qCACW,SAAA,GAAY,SAAA,CAAU,CAAA,UAAW,6BAAA,GAClD,oBAAA,CAAqB,SAAA,CAAU,CAAA,KAC/B,SAAA,CAAU,CAAA,UAAW,MAAA,oBACnB,0BAAA,CAA2B,SAAA,CAAU,CAAA;AAAA,UAI5B,0BAAA;EAAA,SACN,GAAA,EAAK,sBAAA;AAAA;;;;;;;iBASA,gCAAA,CACd,SAAA,EAAW,4BAAA,EACX,OAAA,EAAS,0BAAA,EACT,IAAA,uBACC,MAAA;;;UCvGc,QAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,GAAU,MAAA;AAAA;AAAA,UAGJ,uBAAA;EAAA,SACN,UAAA;EAAA,SACA,KAAA;AAAA"}

package/dist/index.mjs

@@ -1 +1,32 @@
-export {};
+import { instantiateAuthoringEntityType } from "@prisma-next/framework-components/authoring";
+//#region src/composed-helpers-scaffolding.ts
+/**
+* Walks an entity-type namespace (after cross-pack merge) and produces the
+* runtime callable surface mirroring its tree shape. Each leaf
+* descriptor becomes a function `(input) => factory(input, ctx)`;
+* nested namespace objects recurse.
+*/
+function createEntityHelpersFromNamespace(namespace, options, path = []) {
+	const result = {};
+	for (const [key, value] of Object.entries(namespace)) {
+		const currentPath = [...path, key];
+		if (isLeafEntityDescriptor(value)) {
+			result[key] = createEntityHelper(currentPath.join("."), value, options);
+			continue;
+		}
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) result[key] = createEntityHelpersFromNamespace(value, options, currentPath);
+	}
+	return result;
+}
+function isLeafEntityDescriptor(value) {
+	if (typeof value !== "object" || value === null || value.kind !== "entity") return false;
+	const discriminator = value.discriminator;
+	return typeof discriminator === "string" && discriminator.length > 0;
+}
+function createEntityHelper(helperPath, descriptor, options) {
+	return (...args) => instantiateAuthoringEntityType(helperPath, descriptor, args, options.ctx);
+}
+//#endregion
+export { createEntityHelpersFromNamespace };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/composed-helpers-scaffolding.ts"],"sourcesContent":["import type {\n  AuthoringEntityContext,\n  AuthoringEntityTypeDescriptor,\n  AuthoringEntityTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\nimport { instantiateAuthoringEntityType } from '@prisma-next/framework-components/authoring';\n\n/**\n * Family-agnostic merge / instantiation scaffolding for pack-bag-driven\n * authoring contributions. The per-namespace shape (`field`, `type`,\n * `entityTypes`) is parameterized by the discriminator key so each\n * namespace can reuse the same extractor + cross-pack merger without\n * re-deriving the template per family. Call sites flatten merged\n * `entityTypes` onto the user-facing top-level helpers surface\n * alongside the built-in `model` / `rel` (e.g. `helpers.enum(...)`).\n * The contribution data structure stays as\n * `authoring.entityTypes.<name>` — pack authors keep contributing\n * through the namespace; the composed-helpers template performs the\n * rename in the type system.\n *\n * SQL-specific composition (the `field` / `model` / `rel` / `type` core\n * helpers, the SQL index-types merge) lives in the SQL contract-ts\n * package and imports from here.\n */\n\nexport type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (\n  value: infer I,\n) => void\n  ? I\n  : never;\n\nexport type AuthoringNamespaceKey = 'field' | 'type' | 'entityTypes';\n\nexport type ExtractAuthoringNamespaceFromPack<\n  Pack,\n  Key extends AuthoringNamespaceKey,\n  EmptyNamespace,\n> = Pack extends {\n  readonly authoring?: { readonly [P in Key]?: infer Namespace };\n}\n  ? Namespace extends Record<string, unknown>\n    ? Namespace\n    : EmptyNamespace\n  : EmptyNamespace;\n\nexport type MergeExtensionAuthoringNamespaces<\n  ExtensionPacks,\n  Key extends AuthoringNamespaceKey,\n  EmptyNamespace = Record<never, never>,\n> =\n  ExtensionPacks extends Record<string, unknown>\n    ? keyof ExtensionPacks extends never\n      ? EmptyNamespace\n      : UnionToIntersection<\n          {\n            [K in keyof ExtensionPacks]: ExtractAuthoringNamespaceFromPack<\n              ExtensionPacks[K],\n              Key,\n              EmptyNamespace\n            >;\n          }[keyof ExtensionPacks]\n        >\n    : EmptyNamespace;\n\n/**\n * Entity-helper shape derivation. Mirrors `FieldHelpersFromNamespace` /\n * `TypeHelpersFromNamespace` in the SQL package: leaf descriptors become\n * callable helpers; nested namespaces recurse.\n */\ntype ExtractFactoryInputAndOutput<Descriptor extends AuthoringEntityTypeDescriptor> =\n  Descriptor['output'] extends {\n    readonly factory: (input: infer Input, ctx: AuthoringEntityContext) => infer Output;\n  }\n    ? { input: Input; output: Output }\n    : { input: unknown; output: unknown };\n\nexport type EntityHelperFunction<Descriptor extends AuthoringEntityTypeDescriptor> =\n  ExtractFactoryInputAndOutput<Descriptor> extends { input: infer Input; output: infer Output }\n    ? (input: Input) => Output\n    : never;\n\nexport type EntityHelpersFromNamespace<Namespace> = {\n  readonly [K in keyof Namespace]: Namespace[K] extends AuthoringEntityTypeDescriptor\n    ? EntityHelperFunction<Namespace[K]>\n    : Namespace[K] extends Record<string, unknown>\n      ? EntityHelpersFromNamespace<Namespace[K]>\n      : never;\n};\n\nexport interface EntityHelperFactoryOptions {\n  readonly ctx: AuthoringEntityContext;\n}\n\n/**\n * Walks an entity-type namespace (after cross-pack merge) and produces the\n * runtime callable surface mirroring its tree shape. Each leaf\n * descriptor becomes a function `(input) => factory(input, ctx)`;\n * nested namespace objects recurse.\n */\nexport function createEntityHelpersFromNamespace(\n  namespace: AuthoringEntityTypeNamespace,\n  options: EntityHelperFactoryOptions,\n  path: readonly string[] = [],\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(namespace)) {\n    const currentPath = [...path, key];\n    if (isLeafEntityDescriptor(value)) {\n      result[key] = createEntityHelper(currentPath.join('.'), value, options);\n      continue;\n    }\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      result[key] = createEntityHelpersFromNamespace(\n        value as AuthoringEntityTypeNamespace,\n        options,\n        currentPath,\n      );\n    }\n  }\n  return result;\n}\n\nfunction isLeafEntityDescriptor(value: unknown): value is AuthoringEntityTypeDescriptor {\n  if (\n    typeof value !== 'object' ||\n    value === null ||\n    (value as { kind?: unknown }).kind !== 'entity'\n  ) {\n    return false;\n  }\n  const discriminator = (value as { discriminator?: unknown }).discriminator;\n  return typeof discriminator === 'string' && discriminator.length > 0;\n}\n\nfunction createEntityHelper(\n  helperPath: string,\n  descriptor: AuthoringEntityTypeDescriptor,\n  options: EntityHelperFactoryOptions,\n): (...args: readonly unknown[]) => unknown {\n  return (...args: readonly unknown[]) =>\n    instantiateAuthoringEntityType(helperPath, descriptor, args, options.ctx);\n}\n"],"mappings":";;;;;;;;AAmGA,SAAgB,iCACd,WACA,SACA,OAA0B,EAAE,EACH;CACzB,MAAM,SAAkC,EAAE;CAC1C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,UAAU,EAAE;EACpD,MAAM,cAAc,CAAC,GAAG,MAAM,IAAI;EAClC,IAAI,uBAAuB,MAAM,EAAE;GACjC,OAAO,OAAO,mBAAmB,YAAY,KAAK,IAAI,EAAE,OAAO,QAAQ;GACvE;;EAEF,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM,EACtE,OAAO,OAAO,iCACZ,OACA,SACA,YACD;;CAGL,OAAO;;AAGT,SAAS,uBAAuB,OAAwD;CACtF,IACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA6B,SAAS,UAEvC,OAAO;CAET,MAAM,gBAAiB,MAAsC;CAC7D,OAAO,OAAO,kBAAkB,YAAY,cAAc,SAAS;;AAGrE,SAAS,mBACP,YACA,YACA,SAC0C;CAC1C,QAAQ,GAAG,SACT,+BAA+B,YAAY,YAAY,MAAM,QAAQ,IAAI"}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@prisma-next/contract-authoring",
-  "version": "0.7.0-dev.7",
+  "version": "0.8.0-dev.1",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Target-agnostic authored storage descriptor types for Prisma Next",
-  "dependencies": {},
+  "dependencies": {
+    "@prisma-next/framework-components": "0.8.0-dev.1"
+  },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.7.0-dev.7",
-    "@prisma-next/tsdown": "0.7.0-dev.7",
+    "@prisma-next/tsconfig": "0.8.0-dev.1",
+    "@prisma-next/tsdown": "0.8.0-dev.1",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5"
@@ -21,8 +23,6 @@
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "repository": {
     "type": "git",

package/src/composed-helpers-scaffolding.ts

@@ -0,0 +1,142 @@
+import type {
+  AuthoringEntityContext,
+  AuthoringEntityTypeDescriptor,
+  AuthoringEntityTypeNamespace,
+} from '@prisma-next/framework-components/authoring';
+import { instantiateAuthoringEntityType } from '@prisma-next/framework-components/authoring';
+
+/**
+ * Family-agnostic merge / instantiation scaffolding for pack-bag-driven
+ * authoring contributions. The per-namespace shape (`field`, `type`,
+ * `entityTypes`) is parameterized by the discriminator key so each
+ * namespace can reuse the same extractor + cross-pack merger without
+ * re-deriving the template per family. Call sites flatten merged
+ * `entityTypes` onto the user-facing top-level helpers surface
+ * alongside the built-in `model` / `rel` (e.g. `helpers.enum(...)`).
+ * The contribution data structure stays as
+ * `authoring.entityTypes.<name>` — pack authors keep contributing
+ * through the namespace; the composed-helpers template performs the
+ * rename in the type system.
+ *
+ * SQL-specific composition (the `field` / `model` / `rel` / `type` core
+ * helpers, the SQL index-types merge) lives in the SQL contract-ts
+ * package and imports from here.
+ */
+
+export type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (
+  value: infer I,
+) => void
+  ? I
+  : never;
+
+export type AuthoringNamespaceKey = 'field' | 'type' | 'entityTypes';
+
+export type ExtractAuthoringNamespaceFromPack<
+  Pack,
+  Key extends AuthoringNamespaceKey,
+  EmptyNamespace,
+> = Pack extends {
+  readonly authoring?: { readonly [P in Key]?: infer Namespace };
+}
+  ? Namespace extends Record<string, unknown>
+    ? Namespace
+    : EmptyNamespace
+  : EmptyNamespace;
+
+export type MergeExtensionAuthoringNamespaces<
+  ExtensionPacks,
+  Key extends AuthoringNamespaceKey,
+  EmptyNamespace = Record<never, never>,
+> =
+  ExtensionPacks extends Record<string, unknown>
+    ? keyof ExtensionPacks extends never
+      ? EmptyNamespace
+      : UnionToIntersection<
+          {
+            [K in keyof ExtensionPacks]: ExtractAuthoringNamespaceFromPack<
+              ExtensionPacks[K],
+              Key,
+              EmptyNamespace
+            >;
+          }[keyof ExtensionPacks]
+        >
+    : EmptyNamespace;
+
+/**
+ * Entity-helper shape derivation. Mirrors `FieldHelpersFromNamespace` /
+ * `TypeHelpersFromNamespace` in the SQL package: leaf descriptors become
+ * callable helpers; nested namespaces recurse.
+ */
+type ExtractFactoryInputAndOutput<Descriptor extends AuthoringEntityTypeDescriptor> =
+  Descriptor['output'] extends {
+    readonly factory: (input: infer Input, ctx: AuthoringEntityContext) => infer Output;
+  }
+    ? { input: Input; output: Output }
+    : { input: unknown; output: unknown };
+
+export type EntityHelperFunction<Descriptor extends AuthoringEntityTypeDescriptor> =
+  ExtractFactoryInputAndOutput<Descriptor> extends { input: infer Input; output: infer Output }
+    ? (input: Input) => Output
+    : never;
+
+export type EntityHelpersFromNamespace<Namespace> = {
+  readonly [K in keyof Namespace]: Namespace[K] extends AuthoringEntityTypeDescriptor
+    ? EntityHelperFunction<Namespace[K]>
+    : Namespace[K] extends Record<string, unknown>
+      ? EntityHelpersFromNamespace<Namespace[K]>
+      : never;
+};
+
+export interface EntityHelperFactoryOptions {
+  readonly ctx: AuthoringEntityContext;
+}
+
+/**
+ * Walks an entity-type namespace (after cross-pack merge) and produces the
+ * runtime callable surface mirroring its tree shape. Each leaf
+ * descriptor becomes a function `(input) => factory(input, ctx)`;
+ * nested namespace objects recurse.
+ */
+export function createEntityHelpersFromNamespace(
+  namespace: AuthoringEntityTypeNamespace,
+  options: EntityHelperFactoryOptions,
+  path: readonly string[] = [],
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(namespace)) {
+    const currentPath = [...path, key];
+    if (isLeafEntityDescriptor(value)) {
+      result[key] = createEntityHelper(currentPath.join('.'), value, options);
+      continue;
+    }
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      result[key] = createEntityHelpersFromNamespace(
+        value as AuthoringEntityTypeNamespace,
+        options,
+        currentPath,
+      );
+    }
+  }
+  return result;
+}
+
+function isLeafEntityDescriptor(value: unknown): value is AuthoringEntityTypeDescriptor {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    (value as { kind?: unknown }).kind !== 'entity'
+  ) {
+    return false;
+  }
+  const discriminator = (value as { discriminator?: unknown }).discriminator;
+  return typeof discriminator === 'string' && discriminator.length > 0;
+}
+
+function createEntityHelper(
+  helperPath: string,
+  descriptor: AuthoringEntityTypeDescriptor,
+  options: EntityHelperFactoryOptions,
+): (...args: readonly unknown[]) => unknown {
+  return (...args: readonly unknown[]) =>
+    instantiateAuthoringEntityType(helperPath, descriptor, args, options.ctx);
+}

package/src/index.ts

@@ -1 +1,11 @@
+export type {
+  AuthoringNamespaceKey,
+  EntityHelperFactoryOptions,
+  EntityHelperFunction,
+  EntityHelpersFromNamespace,
+  ExtractAuthoringNamespaceFromPack,
+  MergeExtensionAuthoringNamespaces,
+  UnionToIntersection,
+} from './composed-helpers-scaffolding';
+export { createEntityHelpersFromNamespace } from './composed-helpers-scaffolding';
 export type { ForeignKeyDefaultsState, IndexDef } from './descriptors';