@palantir/pack.document-schema.type-gen 0.9.0 → 0.10.0

package/build/esm/utils/schema/generateVersionedTypesFromSchema.js

@@ -16,110 +16,14 @@
 
 import { formatVariantName } from "../formatVariantName.js";
 import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
-import { resolveSchemaChain } from "./resolveSchemaChain.js";
-import { findRecordExportName, isRecordSchema, isUnionSchema, TypeKind, typesFilePath, versionedTypeName, versionedWriteTypeName } from "./runtimeSchema.js";
-function detectUsedRefTypes(schema) {
-  const refTypes = new Set();
-  function scanField(field) {
-    switch (field.type) {
-      case TypeKind.ARRAY:
-        if (field.items) scanField(field.items);
-        break;
-      case TypeKind.DOC_REF:
-        refTypes.add("DocumentRef");
-        break;
-      case TypeKind.MEDIA_REF:
-        refTypes.add("MediaRef");
-        break;
-      case TypeKind.OBJECT_REF:
-        refTypes.add("ObjectRef");
-        break;
-      case TypeKind.OPTIONAL:
-        if (field.item) scanField(field.item);
-        break;
-      case TypeKind.USER_REF:
-        refTypes.add("UserRef");
-        break;
-    }
-  }
-  for (const item of Object.values(schema)) {
-    if (isRecordSchema(item)) {
-      for (const f of Object.values(item.fields)) {
-        scanField(f);
-      }
-    } else if (isUnionSchema(item)) {
-      for (const v of Object.values(item.variants)) {
-        scanField(v);
-      }
-    }
-  }
-  return refTypes;
-}
-function collectReferencedTypes(fieldType, schema, version, out) {
-  switch (fieldType.type) {
-    case TypeKind.ARRAY:
-      if (fieldType.items) collectReferencedTypes(fieldType.items, schema, version, out);
-      break;
-    case TypeKind.OPTIONAL:
-      if (fieldType.item) collectReferencedTypes(fieldType.item, schema, version, out);
-      break;
-    case TypeKind.REF:
-      {
-        const name = fieldType.refType === "record" ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
-        if (name == null) {
-          throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);
-        }
-        out.add(versionedTypeName(name, version));
-        break;
-      }
-  }
-}
-function convertTypeToTypeScript(fieldType, schema, version) {
-  switch (fieldType.type) {
-    case TypeKind.ANY:
-      return "any";
-    case TypeKind.ARRAY:
-      if (fieldType.items == null) {
-        throw new Error("Array field is missing items type");
-      }
-      return `readonly ${convertTypeToTypeScript(fieldType.items, schema, version)}[]`;
-    case TypeKind.BOOLEAN:
-      return "boolean";
-    case TypeKind.DOC_REF:
-      return "DocumentRef";
-    case TypeKind.DOUBLE:
-      return "number";
-    case TypeKind.MEDIA_REF:
-      return "MediaRef";
-    case TypeKind.OBJECT_REF:
-      return "ObjectRef";
-    case TypeKind.OPTIONAL:
-      if (fieldType.item == null) {
-        throw new Error("Optional field is missing inner type");
-      }
-      return convertTypeToTypeScript(fieldType.item, schema, version);
-    case TypeKind.REF:
-      {
-        const name = fieldType.refType === "record" && schema != null ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
-        if (name == null) {
-          throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);
-        }
-        return version != null ? versionedTypeName(name, version) : name;
-      }
-    case TypeKind.STRING:
-      return "string";
-    case TypeKind.USER_REF:
-      return "UserRef";
-    default:
-      throw new Error(`Unknown schema field type: ${fieldType.type}`);
-  }
-}
-
+import { collectReferencedTypes, convertFieldTypeToTypeScript, detectUsedRefTypes } from "../ir/irFieldHelpers.js";
+import { resolveMinVersion } from "./resolveSchemaChain.js";
+import { typesFilePath, versionedTypeName, versionedWriteTypeName } from "./runtimeSchema.js";
 /**
  * Generate read types for a specific schema version.
  */
-function generateReadTypesForVersion(version, schema) {
-  const usedRefTypes = detectUsedRefTypes(schema);
+function generateReadTypesForVersion(version, ir) {
+  const usedRefTypes = detectUsedRefTypes(ir);
   let output = GENERATED_FILE_HEADER;
   if (usedRefTypes.size > 0) {
     const refTypesList = Array.from(usedRefTypes).sort().join(", ");
@@ -128,42 +32,46 @@ function generateReadTypesForVersion(version, schema) {
   output += "\n";
 
   // Generate record interfaces
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (!isRecordSchema(item)) continue;
-    const typeName = versionedTypeName(exportName, version);
-    if (item.docs) {
-      output += `/**\n * ${item.docs}\n */\n`;
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    const record = modelDef.record;
+    const typeName = versionedTypeName(modelKey, version);
+    if (record.description) {
+      output += `/**\n * ${record.description}\n */\n`;
     }
     output += `export interface ${typeName} {\n`;
-    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
-      const tsType = convertTypeToTypeScript(fieldType, schema, version);
-      const optional = fieldType.type === TypeKind.OPTIONAL ? "?" : "";
-      output += `  readonly ${fieldName}${optional}: ${tsType};\n`;
+    for (const field of record.fields) {
+      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);
+      const optional = field.isOptional ? "?" : "";
+      output += `  readonly ${field.key}${optional}: ${tsType};\n`;
     }
     output += "}\n\n";
   }
 
   // Generate union types
-  const unionEntries = Object.entries(schema).filter(([_, item]) => isUnionSchema(item));
-  for (const [exportName, item] of unionEntries) {
-    if (!isUnionSchema(item)) continue;
-    const typeName = versionedTypeName(exportName, version);
-    const discriminantField = item.discriminant;
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "union") continue;
+    const union = modelDef.union;
+    const typeName = versionedTypeName(modelKey, version);
+    const discriminantField = union.discriminant;
     const variantInterfaces = [];
-    for (const [variantName, variantType] of Object.entries(item.variants)) {
+    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {
       const interfaceName = `${typeName}${formatVariantName(variantName)}`;
       variantInterfaces.push({
         name: interfaceName,
         discriminatorValue: variantName
       });
-      if (variantType.type === TypeKind.REF && variantType.refType === "record") {
-        const recordExport = findRecordExportName(variantType.name, schema);
-        const recordTypeName = recordExport ? versionedTypeName(recordExport, version) : variantType.name;
+
+      // Look up the variant's model to check if it's a record
+      const variantModel = ir.models[variantModelKey];
+      if (variantModel != null && variantModel.type === "record") {
+        const recordTypeName = versionedTypeName(variantModelKey, version);
         output += `export interface ${interfaceName} extends ${recordTypeName} {\n`;
         output += `  readonly ${discriminantField}: "${variantName}";\n`;
         output += "}\n\n";
       } else {
-        const tsType = convertTypeToTypeScript(variantType, schema, version);
+        // Non-record variant (e.g. another union): emit a value field referencing the type
+        const tsType = versionedTypeName(variantModelKey, version);
         output += `export interface ${interfaceName} {\n`;
         output += `  readonly ${discriminantField}: "${variantName}";\n`;
         output += `  readonly value: ${tsType};\n`;
@@ -184,15 +92,15 @@ function generateReadTypesForVersion(version, schema) {
  * Generate write types for a specific schema version.
  * All fields are optional in write types.
  */
-function generateWriteTypesForVersion(version, schema) {
-  const usedRefTypes = detectUsedRefTypes(schema);
+function generateWriteTypesForVersion(version, ir) {
+  const usedRefTypes = detectUsedRefTypes(ir);
 
   // Collect referenced schema-local types (refs to other records/unions)
   const referencedLocalTypes = new Set();
-  for (const item of Object.values(schema)) {
-    if (!isRecordSchema(item)) continue;
-    for (const fieldType of Object.values(item.fields)) {
-      collectReferencedTypes(fieldType, schema, version, referencedLocalTypes);
+  for (const modelDef of Object.values(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    for (const field of modelDef.record.fields) {
+      collectReferencedTypes(field.fieldType, version, referencedLocalTypes);
     }
   }
   let output = GENERATED_FILE_HEADER;
@@ -207,14 +115,14 @@ function generateWriteTypesForVersion(version, schema) {
   output += "\n";
 
   // Generate record write types
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (!isRecordSchema(item)) continue;
-    const typeName = versionedWriteTypeName(exportName, version);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    const typeName = versionedWriteTypeName(modelKey, version);
     output += `export type ${typeName} = {\n`;
-    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
+    for (const field of modelDef.record.fields) {
       // All fields are optional in write types
-      const tsType = convertTypeToTypeScript(fieldType, schema, version);
-      output += `  readonly ${fieldName}?: ${tsType};\n`;
+      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);
+      output += `  readonly ${field.key}?: ${tsType};\n`;
     }
     output += "};\n\n";
   }
@@ -225,23 +133,23 @@ function generateWriteTypesForVersion(version, schema) {
  * Generate the types.ts re-export file that maps unversioned names to the latest version.
  */
 function generateTypesReExport({
-  schema,
+  ir,
   version
 }) {
   const reExports = [];
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (isRecordSchema(item)) {
-      const versioned = versionedTypeName(exportName, version);
-      reExports.push(`export type { ${versioned} as ${exportName} } from "${typesFilePath(version)}";`);
-    } else if (isUnionSchema(item)) {
-      const versioned = versionedTypeName(exportName, version);
-      reExports.push(`export type { ${versioned} as ${exportName} } from "${typesFilePath(version)}";`);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type === "record") {
+      const versioned = versionedTypeName(modelKey, version);
+      reExports.push(`export type { ${versioned} as ${modelKey} } from "${typesFilePath(version)}";`);
+    } else if (modelDef.type === "union") {
+      const versioned = versionedTypeName(modelKey, version);
+      reExports.push(`export type { ${versioned} as ${modelKey} } from "${typesFilePath(version)}";`);
 
       // Also re-export union variant types
-      for (const variantName of Object.keys(item.variants)) {
+      for (const variantName of Object.keys(modelDef.union.variants)) {
         const formattedVariant = formatVariantName(variantName);
-        const versionedVariant = `${versionedTypeName(exportName, version)}${formattedVariant}`;
-        reExports.push(`export type { ${versionedVariant} as ${`${exportName}${formattedVariant}`} } from "${typesFilePath(version)}";`);
+        const versionedVariant = `${versionedTypeName(modelKey, version)}${formattedVariant}`;
+        reExports.push(`export type { ${versionedVariant} as ${`${modelKey}${formattedVariant}`} } from "${typesFilePath(version)}";`);
       }
     }
   }
@@ -249,27 +157,25 @@ function generateTypesReExport({
 }
 
 /**
- * Generate per-version public types and write types from a schema with version chain.
- *
- * @param schema - The schema, initial or versioned
- * @param minSupportedVersion - Minimum version to generate types for (defaults to latest)
- * @returns Object containing generated code for each output file
+ * Generate per-version public types and write types from an already-resolved
+ * versioned IR chain.
  */
-export function generateVersionedTypesFromSchema(schema, minSupportedVersion) {
+export function generateVersionedTypesFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
   const {
-    chain,
-    latestVersion,
     minVersion
-  } = resolveSchemaChain(schema, minSupportedVersion);
+  } = resolveMinVersion(chain, minSupportedVersion);
   const readTypes = new Map();
   const writeTypes = new Map();
   for (const {
     version,
-    schema: versionSchema
+    ir
   } of chain) {
     if (version < minVersion) continue;
-    readTypes.set(version, generateReadTypesForVersion(version, versionSchema));
-    writeTypes.set(version, generateWriteTypesForVersion(version, versionSchema));
+    readTypes.set(version, generateReadTypesForVersion(version, ir));
+    writeTypes.set(version, generateWriteTypesForVersion(version, ir));
   }
   const typesReExport = generateTypesReExport(chain[chain.length - 1]);
   return {

package/build/esm/utils/schema/generateVersionedTypesFromSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateVersionedTypesFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","resolveSchemaChain","findRecordExportName","isRecordSchema","isUnionSchema","TypeKind","typesFilePath","versionedTypeName","versionedWriteTypeName","detectUsedRefTypes","schema","refTypes","Set","scanField","field","type","ARRAY","items","DOC_REF","add","MEDIA_REF","OBJECT_REF","OPTIONAL","item","USER_REF","Object","values","f","fields","v","variants","collectReferencedTypes","fieldType","version","out","REF","name","refType","Error","convertTypeToTypeScript","ANY","BOOLEAN","DOUBLE","STRING","generateReadTypesForVersion","usedRefTypes","output","size","refTypesList","Array","from","sort","join","exportName","entries","typeName","docs","fieldName","tsType","optional","unionEntries","filter","_","discriminantField","discriminant","variantInterfaces","variantName","variantType","interfaceName","push","discriminatorValue","recordExport","recordTypeName","map","variant","generateWriteTypesForVersion","referencedLocalTypes","localTypesList","generateTypesReExport","reExports","versioned","keys","formattedVariant","versionedVariant","generateVersionedTypesFromSchema","minSupportedVersion","chain","latestVersion","minVersion","readTypes","Map","writeTypes","versionSchema","set","typesReExport","length"],"sources":["generateVersionedTypesFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition } from \"@palantir/pack.schema\";\nimport { formatVariantName } from \"../formatVariantName.js\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport type { VersionedSchemaEntry } from \"./resolveSchemaChain.js\";\nimport { resolveSchemaChain } from \"./resolveSchemaChain.js\";\nimport type { RuntimeSchema, SchemaField } from \"./runtimeSchema.js\";\nimport {\n  findRecordExportName,\n  isRecordSchema,\n  isUnionSchema,\n  TypeKind,\n  typesFilePath,\n  versionedTypeName,\n  versionedWriteTypeName,\n} from \"./runtimeSchema.js\";\n\nexport interface VersionedTypesOutput {\n  /** types_vN.ts files keyed by version number */\n  readTypes: Map<number, string>;\n  /** writeTypes_vN.ts files keyed by version number */\n  writeTypes: Map<number, string>;\n  /** types.ts re-export of latest version types under unversioned names */\n  typesReExport: string;\n}\n\nfunction detectUsedRefTypes(schema: RuntimeSchema): Set<string> {\n  const refTypes = new Set<string>();\n\n  function scanField(field: SchemaField): void {\n    switch (field.type) {\n      case TypeKind.ARRAY:\n        if (field.items) scanField(field.items);\n        break;\n      case TypeKind.DOC_REF:\n        refTypes.add(\"DocumentRef\");\n        break;\n      case TypeKind.MEDIA_REF:\n        refTypes.add(\"MediaRef\");\n        break;\n      case TypeKind.OBJECT_REF:\n        refTypes.add(\"ObjectRef\");\n        break;\n      case TypeKind.OPTIONAL:\n        if (field.item) scanField(field.item);\n        break;\n      case TypeKind.USER_REF:\n        refTypes.add(\"UserRef\");\n        break;\n    }\n  }\n\n  for (const item of Object.values(schema)) {\n    if (isRecordSchema(item)) {\n      for (const f of Object.values(item.fields)) {\n        scanField(f);\n      }\n    } else if (isUnionSchema(item)) {\n      for (const v of Object.values(item.variants)) {\n        scanField(v);\n      }\n    }\n  }\n\n  return refTypes;\n}\n\nfunction collectReferencedTypes(\n  fieldType: SchemaField,\n  schema: RuntimeSchema,\n  version: number,\n  out: Set<string>,\n): void {\n  switch (fieldType.type) {\n    case TypeKind.ARRAY:\n      if (fieldType.items) collectReferencedTypes(fieldType.items, schema, version, out);\n      break;\n    case TypeKind.OPTIONAL:\n      if (fieldType.item) collectReferencedTypes(fieldType.item, schema, version, out);\n      break;\n    case TypeKind.REF: {\n      const name = fieldType.refType === \"record\"\n        ? findRecordExportName(fieldType.name!, schema) ?? fieldType.name\n        : fieldType.name;\n      if (name == null) {\n        throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);\n      }\n      out.add(versionedTypeName(name, version));\n      break;\n    }\n  }\n}\n\nfunction convertTypeToTypeScript(\n  fieldType: SchemaField,\n  schema?: RuntimeSchema,\n  version?: number,\n): string {\n  switch (fieldType.type) {\n    case TypeKind.ANY:\n      return \"any\";\n    case TypeKind.ARRAY:\n      if (fieldType.items == null) {\n        throw new Error(\"Array field is missing items type\");\n      }\n      return `readonly ${convertTypeToTypeScript(fieldType.items, schema, version)}[]`;\n    case TypeKind.BOOLEAN:\n      return \"boolean\";\n    case TypeKind.DOC_REF:\n      return \"DocumentRef\";\n    case TypeKind.DOUBLE:\n      return \"number\";\n    case TypeKind.MEDIA_REF:\n      return \"MediaRef\";\n    case TypeKind.OBJECT_REF:\n      return \"ObjectRef\";\n    case TypeKind.OPTIONAL:\n      if (fieldType.item == null) {\n        throw new Error(\"Optional field is missing inner type\");\n      }\n      return convertTypeToTypeScript(fieldType.item, schema, version);\n    case TypeKind.REF: {\n      const name = fieldType.refType === \"record\" && schema != null\n        ? findRecordExportName(fieldType.name!, schema) ?? fieldType.name\n        : fieldType.name;\n      if (name == null) {\n        throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);\n      }\n      return version != null ? versionedTypeName(name, version) : name;\n    }\n    case TypeKind.STRING:\n      return \"string\";\n    case TypeKind.USER_REF:\n      return \"UserRef\";\n    default:\n      throw new Error(`Unknown schema field type: ${fieldType.type}`);\n  }\n}\n\n/**\n * Generate read types for a specific schema version.\n */\nfunction generateReadTypesForVersion(\n  version: number,\n  schema: RuntimeSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(schema);\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record interfaces\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isRecordSchema(item)) continue;\n\n    const typeName = versionedTypeName(exportName, version);\n\n    if (item.docs) {\n      output += `/**\\n * ${item.docs}\\n */\\n`;\n    }\n\n    output += `export interface ${typeName} {\\n`;\n\n    for (const [fieldName, fieldType] of Object.entries(item.fields)) {\n      const tsType = convertTypeToTypeScript(fieldType, schema, version);\n      const optional = fieldType.type === TypeKind.OPTIONAL ? \"?\" : \"\";\n      output += `  readonly ${fieldName}${optional}: ${tsType};\\n`;\n    }\n\n    output += \"}\\n\\n\";\n  }\n\n  // Generate union types\n  const unionEntries = Object.entries(schema).filter(\n    ([_, item]) => isUnionSchema(item),\n  );\n\n  for (const [exportName, item] of unionEntries) {\n    if (!isUnionSchema(item)) continue;\n\n    const typeName = versionedTypeName(exportName, version);\n    const discriminantField = item.discriminant;\n    const variantInterfaces: Array<{ name: string; discriminatorValue: string }> = [];\n\n    for (const [variantName, variantType] of Object.entries(item.variants)) {\n      const interfaceName = `${typeName}${formatVariantName(variantName)}`;\n      variantInterfaces.push({ name: interfaceName, discriminatorValue: variantName });\n\n      if (variantType.type === TypeKind.REF && variantType.refType === \"record\") {\n        const recordExport = findRecordExportName(variantType.name!, schema);\n        const recordTypeName = recordExport\n          ? versionedTypeName(recordExport, version)\n          : variantType.name!;\n        output += `export interface ${interfaceName} extends ${recordTypeName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += \"}\\n\\n\";\n      } else {\n        const tsType = convertTypeToTypeScript(variantType, schema, version);\n        output += `export interface ${interfaceName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += `  readonly value: ${tsType};\\n`;\n        output += \"}\\n\\n\";\n      }\n    }\n\n    output += `export type ${typeName} = ${variantInterfaces.map(v => v.name).join(\" | \")};\\n\\n`;\n\n    for (const variant of variantInterfaces) {\n      output +=\n        `export function is${variant.name}(value: ${typeName}): value is ${variant.name} {\\n`;\n      output += `  return value.${discriminantField} === \"${variant.discriminatorValue}\";\\n`;\n      output += \"}\\n\\n\";\n    }\n  }\n\n  return output;\n}\n\n/**\n * Generate write types for a specific schema version.\n * All fields are optional in write types.\n */\nfunction generateWriteTypesForVersion(\n  version: number,\n  schema: RuntimeSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(schema);\n\n  // Collect referenced schema-local types (refs to other records/unions)\n  const referencedLocalTypes = new Set<string>();\n  for (const item of Object.values(schema)) {\n    if (!isRecordSchema(item)) continue;\n    for (const fieldType of Object.values(item.fields)) {\n      collectReferencedTypes(fieldType, schema, version, referencedLocalTypes);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  if (referencedLocalTypes.size > 0) {\n    const localTypesList = Array.from(referencedLocalTypes).sort().join(\", \");\n    output += `import type { ${localTypesList} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record write types\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isRecordSchema(item)) continue;\n\n    const typeName = versionedWriteTypeName(exportName, version);\n\n    output += `export type ${typeName} = {\\n`;\n\n    for (const [fieldName, fieldType] of Object.entries(item.fields)) {\n      // All fields are optional in write types\n      const tsType = convertTypeToTypeScript(fieldType, schema, version);\n      output += `  readonly ${fieldName}?: ${tsType};\\n`;\n    }\n\n    output += \"};\\n\\n\";\n  }\n\n  return output;\n}\n\n/**\n * Generate the types.ts re-export file that maps unversioned names to the latest version.\n */\nfunction generateTypesReExport({ schema, version }: VersionedSchemaEntry): string {\n  const reExports: string[] = [];\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item)) {\n      const versioned = versionedTypeName(exportName, version);\n      reExports.push(\n        `export type { ${versioned} as ${exportName} } from \"${typesFilePath(version)}\";`,\n      );\n    } else if (isUnionSchema(item)) {\n      const versioned = versionedTypeName(exportName, version);\n      reExports.push(\n        `export type { ${versioned} as ${exportName} } from \"${typesFilePath(version)}\";`,\n      );\n\n      // Also re-export union variant types\n      for (const variantName of Object.keys(item.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedTypeName(exportName, version)}${formattedVariant}`;\n        const unversionedVariant = `${exportName}${formattedVariant}`;\n        reExports.push(\n          `export type { ${versionedVariant} as ${unversionedVariant} } from \"${\n            typesFilePath(version)\n          }\";`,\n        );\n      }\n    }\n  }\n\n  return GENERATED_FILE_HEADER + reExports.join(\"\\n\") + \"\\n\";\n}\n\n/**\n * Generate per-version public types and write types from a schema with version chain.\n *\n * @param schema - The schema, initial or versioned\n * @param minSupportedVersion - Minimum version to generate types for (defaults to latest)\n * @returns Object containing generated code for each output file\n */\nexport function generateVersionedTypesFromSchema(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): VersionedTypesOutput {\n  const { chain, latestVersion, minVersion } = resolveSchemaChain(schema, minSupportedVersion);\n\n  const readTypes = new Map<number, string>();\n  const writeTypes = new Map<number, string>();\n\n  for (const { version, schema: versionSchema } of chain) {\n    if (version < minVersion) continue;\n\n    readTypes.set(version, generateReadTypesForVersion(version, versionSchema));\n    writeTypes.set(version, generateWriteTypesForVersion(version, versionSchema));\n  }\n\n  const typesReExport = generateTypesReExport(chain[chain.length - 1]!);\n\n  return { readTypes, writeTypes, typesReExport };\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"generateVersionedTypesFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","collectReferencedTypes","convertFieldTypeToTypeScript","detectUsedRefTypes","resolveMinVersion","typesFilePath","versionedTypeName","versionedWriteTypeName","generateReadTypesForVersion","version","ir","usedRefTypes","output","size","refTypesList","Array","from","sort","join","modelKey","modelDef","Object","entries","models","type","record","typeName","description","field","fields","tsType","fieldType","optional","isOptional","key","union","discriminantField","discriminant","variantInterfaces","variantName","variantModelKey","variants","interfaceName","push","name","discriminatorValue","variantModel","recordTypeName","map","v","variant","generateWriteTypesForVersion","referencedLocalTypes","Set","values","localTypesList","generateTypesReExport","reExports","versioned","keys","formattedVariant","versionedVariant","generateVersionedTypesFromChain","resolved","minSupportedVersion","chain","minVersion","readTypes","Map","writeTypes","set","typesReExport","length"],"sources":["generateVersionedTypesFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { IRealTimeDocumentSchema } from \"../../lib/pack-docschema-api/pack-docschema-ir/index.js\";\nimport { formatVariantName } from \"../formatVariantName.js\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport {\n  collectReferencedTypes,\n  convertFieldTypeToTypeScript,\n  detectUsedRefTypes,\n} from \"../ir/irFieldHelpers.js\";\nimport type { ResolvedIrChain, VersionedIrEntry } from \"./resolveSchemaChain.js\";\nimport { resolveMinVersion } from \"./resolveSchemaChain.js\";\nimport { typesFilePath, versionedTypeName, versionedWriteTypeName } from \"./runtimeSchema.js\";\n\nexport interface VersionedTypesOutput {\n  /** types_vN.ts files keyed by version number */\n  readTypes: Map<number, string>;\n  /** writeTypes_vN.ts files keyed by version number */\n  writeTypes: Map<number, string>;\n  /** types.ts re-export of latest version types under unversioned names */\n  typesReExport: string;\n}\n\n/**\n * Generate read types for a specific schema version.\n */\nfunction generateReadTypesForVersion(\n  version: number,\n  ir: IRealTimeDocumentSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(ir);\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record interfaces\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n\n    const record = modelDef.record;\n    const typeName = versionedTypeName(modelKey, version);\n\n    if (record.description) {\n      output += `/**\\n * ${record.description}\\n */\\n`;\n    }\n\n    output += `export interface ${typeName} {\\n`;\n\n    for (const field of record.fields) {\n      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);\n      const optional = field.isOptional ? \"?\" : \"\";\n      output += `  readonly ${field.key}${optional}: ${tsType};\\n`;\n    }\n\n    output += \"}\\n\\n\";\n  }\n\n  // Generate union types\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"union\") continue;\n\n    const union = modelDef.union;\n    const typeName = versionedTypeName(modelKey, version);\n    const discriminantField = union.discriminant;\n    const variantInterfaces: Array<{ name: string; discriminatorValue: string }> = [];\n\n    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {\n      const interfaceName = `${typeName}${formatVariantName(variantName)}`;\n      variantInterfaces.push({ name: interfaceName, discriminatorValue: variantName });\n\n      // Look up the variant's model to check if it's a record\n      const variantModel = ir.models[variantModelKey];\n      if (variantModel != null && variantModel.type === \"record\") {\n        const recordTypeName = versionedTypeName(variantModelKey, version);\n        output += `export interface ${interfaceName} extends ${recordTypeName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += \"}\\n\\n\";\n      } else {\n        // Non-record variant (e.g. another union): emit a value field referencing the type\n        const tsType = versionedTypeName(variantModelKey, version);\n        output += `export interface ${interfaceName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += `  readonly value: ${tsType};\\n`;\n        output += \"}\\n\\n\";\n      }\n    }\n\n    output += `export type ${typeName} = ${variantInterfaces.map(v => v.name).join(\" | \")};\\n\\n`;\n\n    for (const variant of variantInterfaces) {\n      output +=\n        `export function is${variant.name}(value: ${typeName}): value is ${variant.name} {\\n`;\n      output += `  return value.${discriminantField} === \"${variant.discriminatorValue}\";\\n`;\n      output += \"}\\n\\n\";\n    }\n  }\n\n  return output;\n}\n\n/**\n * Generate write types for a specific schema version.\n * All fields are optional in write types.\n */\nfunction generateWriteTypesForVersion(\n  version: number,\n  ir: IRealTimeDocumentSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(ir);\n\n  // Collect referenced schema-local types (refs to other records/unions)\n  const referencedLocalTypes = new Set<string>();\n  for (const modelDef of Object.values(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n    for (const field of modelDef.record.fields) {\n      collectReferencedTypes(field.fieldType, version, referencedLocalTypes);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  if (referencedLocalTypes.size > 0) {\n    const localTypesList = Array.from(referencedLocalTypes).sort().join(\", \");\n    output += `import type { ${localTypesList} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record write types\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type !== \"record\") continue;\n\n    const typeName = versionedWriteTypeName(modelKey, version);\n\n    output += `export type ${typeName} = {\\n`;\n\n    for (const field of modelDef.record.fields) {\n      // All fields are optional in write types\n      const tsType = convertFieldTypeToTypeScript(field.fieldType, version);\n      output += `  readonly ${field.key}?: ${tsType};\\n`;\n    }\n\n    output += \"};\\n\\n\";\n  }\n\n  return output;\n}\n\n/**\n * Generate the types.ts re-export file that maps unversioned names to the latest version.\n */\nfunction generateTypesReExport({ ir, version }: VersionedIrEntry): string {\n  const reExports: string[] = [];\n  for (const [modelKey, modelDef] of Object.entries(ir.models)) {\n    if (modelDef.type === \"record\") {\n      const versioned = versionedTypeName(modelKey, version);\n      reExports.push(\n        `export type { ${versioned} as ${modelKey} } from \"${typesFilePath(version)}\";`,\n      );\n    } else if (modelDef.type === \"union\") {\n      const versioned = versionedTypeName(modelKey, version);\n      reExports.push(\n        `export type { ${versioned} as ${modelKey} } from \"${typesFilePath(version)}\";`,\n      );\n\n      // Also re-export union variant types\n      for (const variantName of Object.keys(modelDef.union.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedTypeName(modelKey, version)}${formattedVariant}`;\n        const unversionedVariant = `${modelKey}${formattedVariant}`;\n        reExports.push(\n          `export type { ${versionedVariant} as ${unversionedVariant} } from \"${\n            typesFilePath(version)\n          }\";`,\n        );\n      }\n    }\n  }\n\n  return GENERATED_FILE_HEADER + reExports.join(\"\\n\") + \"\\n\";\n}\n\n/**\n * Generate per-version public types and write types from an already-resolved\n * versioned IR chain.\n */\nexport function generateVersionedTypesFromChain(\n  resolved: ResolvedIrChain,\n  minSupportedVersion?: number,\n): VersionedTypesOutput {\n  const { chain } = resolved;\n  const { minVersion } = resolveMinVersion(chain, minSupportedVersion);\n\n  const readTypes = new Map<number, string>();\n  const writeTypes = new Map<number, string>();\n\n  for (const { version, ir } of chain) {\n    if (version < minVersion) continue;\n\n    readTypes.set(version, generateReadTypesForVersion(version, ir));\n    writeTypes.set(version, generateWriteTypesForVersion(version, ir));\n  }\n\n  const typesReExport = generateTypesReExport(chain[chain.length - 1]!);\n\n  return { readTypes, writeTypes, typesReExport };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/schema/generateVersionedZodFromSchema.js

@@ -16,67 +16,25 @@
 
 import { formatVariantName } from "../formatVariantName.js";
 import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
-import { resolveSchemaChain } from "./resolveSchemaChain.js";
-import { findRecordExportName, isRecordSchema, isUnionSchema, schemaName, TypeKind, typesFilePath, versionedSchemaName, versionedTypeName } from "./runtimeSchema.js";
-function convertFieldTypeToZodSchema(fieldType, schema, version) {
-  switch (fieldType.type) {
-    case TypeKind.ANY:
-      return "z.unknown()";
-    case TypeKind.ARRAY:
-      if (fieldType.items == null) {
-        throw new Error("Array field is missing items type");
-      }
-      return `z.array(${convertFieldTypeToZodSchema(fieldType.items, schema, version)})`;
-    case TypeKind.BOOLEAN:
-      return "z.boolean()";
-    case TypeKind.DOC_REF:
-      return "z.string()";
-    case TypeKind.DOUBLE:
-      return "z.number()";
-    case TypeKind.MEDIA_REF:
-      return "z.string()";
-    case TypeKind.OBJECT_REF:
-      return "z.string()";
-    case TypeKind.OPTIONAL:
-      if (fieldType.item == null) {
-        throw new Error("Optional field is missing inner type");
-      }
-      return `${convertFieldTypeToZodSchema(fieldType.item, schema, version)}.optional()`;
-    case TypeKind.REF:
-      {
-        if (fieldType.name == null) {
-          throw new Error("Ref field is missing a name");
-        }
-        const exportName = fieldType.refType === "record" && schema ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
-        const refSchemaName = version != null ? versionedSchemaName(exportName, version) : `${exportName}Schema`;
-        const refTypeName = version != null ? versionedTypeName(exportName, version) : exportName;
-        return `z.lazy((): ZodType<${refTypeName}> => ${refSchemaName})`;
-      }
-    case TypeKind.STRING:
-      return "z.string()";
-    case TypeKind.USER_REF:
-      return "z.string()";
-    default:
-      throw new Error(`Unknown schema field type: ${fieldType.type}`);
-  }
-}
-
+import { convertFieldTypeToZodSchema } from "../ir/irFieldHelpers.js";
+import { resolveMinVersion } from "./resolveSchemaChain.js";
+import { typesFilePath, versionedSchemaName, versionedTypeName } from "./runtimeSchema.js";
 /**
  * Generate Zod schemas for a specific schema version.
  * Uses `.passthrough()` to preserve unknown fields.
  */
-function generateZodSchemasForVersion(version, schema) {
+function generateZodSchemasForVersion(version, ir) {
   let output = GENERATED_FILE_HEADER;
 
   // Collect type names for import
   const typeNames = [];
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (isRecordSchema(item)) {
-      typeNames.push(versionedTypeName(exportName, version));
-    } else if (isUnionSchema(item)) {
-      typeNames.push(versionedTypeName(exportName, version));
-      for (const variantName of Object.keys(item.variants)) {
-        typeNames.push(`${versionedTypeName(exportName, version)}${formatVariantName(variantName)}`);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type === "record") {
+      typeNames.push(versionedTypeName(modelKey, version));
+    } else if (modelDef.type === "union") {
+      typeNames.push(versionedTypeName(modelKey, version));
+      for (const variantName of Object.keys(modelDef.union.variants)) {
+        typeNames.push(`${versionedTypeName(modelKey, version)}${formatVariantName(variantName)}`);
       }
     }
   }
@@ -88,44 +46,52 @@ function generateZodSchemasForVersion(version, schema) {
   output += "\n";
 
   // Generate record schemas first (unions may depend on them)
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (!isRecordSchema(item)) continue;
-    const zodSchemaName = versionedSchemaName(exportName, version);
-    const typeName = versionedTypeName(exportName, version);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "record") continue;
+    const zodSchemaName = versionedSchemaName(modelKey, version);
+    const typeName = versionedTypeName(modelKey, version);
     const fieldLines = [];
-    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
-      const zodType = convertFieldTypeToZodSchema(fieldType, schema, version);
-      fieldLines.push(`  ${fieldName}: ${zodType}`);
+    for (const field of modelDef.record.fields) {
+      let zodType = convertFieldTypeToZodSchema(field.fieldType, version);
+      if (field.isOptional) {
+        zodType = `${zodType}.optional()`;
+      }
+      fieldLines.push(`  ${field.key}: ${zodType}`);
     }
     output += `export const ${zodSchemaName} = z.object({\n${fieldLines.join(",\n")}\n}).passthrough() satisfies ZodType<${typeName}>;\n\n`;
   }
 
   // Generate union schemas
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (!isUnionSchema(item)) continue;
-    const discriminantField = item.discriminant;
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type !== "union") continue;
+    const union = modelDef.union;
+    const discriminantField = union.discriminant;
     const variantSchemaNames = [];
-    for (const [variantName, variantType] of Object.entries(item.variants)) {
+    for (const [variantName, variantModelKey] of Object.entries(union.variants)) {
       const formattedVariant = formatVariantName(variantName);
-      const variantZodSchemaName = `${versionedSchemaName(exportName, version)}${formattedVariant}`;
-      const variantTypeName = `${versionedTypeName(exportName, version)}${formattedVariant}`;
+      const variantZodSchemaName = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;
+      const variantTypeName = `${versionedTypeName(modelKey, version)}${formattedVariant}`;
       variantSchemaNames.push(variantZodSchemaName);
-      if (variantType.type === TypeKind.REF && variantType.refType === "record") {
-        const recordExport = findRecordExportName(variantType.name, schema);
-        const recordZodSchemaName = recordExport ? versionedSchemaName(recordExport, version) : `${variantType.name}Schema`;
+
+      // Look up the variant's model to check if it's a record
+      const variantModel = ir.models[variantModelKey];
+      if (variantModel != null && variantModel.type === "record") {
+        const recordZodSchemaName = versionedSchemaName(variantModelKey, version);
         output += `export const ${variantZodSchemaName} = ${recordZodSchemaName}.extend({\n`;
         output += `  ${discriminantField}: z.literal("${variantName}")\n`;
         output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
       } else {
-        const zodType = convertFieldTypeToZodSchema(variantType, schema, version);
+        // Non-record variant (e.g. another union): emit a value field referencing the schema
+        const refZodSchemaName = versionedSchemaName(variantModelKey, version);
+        const refTypeName = versionedTypeName(variantModelKey, version);
         output += `export const ${variantZodSchemaName} = z.object({\n`;
         output += `  ${discriminantField}: z.literal("${variantName}"),\n`;
-        output += `  value: ${zodType}\n`;
+        output += `  value: z.lazy((): ZodType<${refTypeName}> => ${refZodSchemaName})\n`;
         output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
       }
     }
-    const unionZodSchemaName = versionedSchemaName(exportName, version);
-    const typeName = versionedTypeName(exportName, version);
+    const unionZodSchemaName = versionedSchemaName(modelKey, version);
+    const typeName = versionedTypeName(modelKey, version);
     output += `export const ${unionZodSchemaName} = z.discriminatedUnion("${discriminantField}", [\n  ${variantSchemaNames.join(",\n  ")}\n]) satisfies ZodType<${typeName}>;\n\n`;
   }
   return output;
@@ -135,24 +101,24 @@ function generateZodSchemasForVersion(version, schema) {
  * Generate the schema.ts re-export file mapping unversioned names to latest version.
  */
 function generateSchemaReExport({
-  schema,
+  ir,
   version
 }) {
   let output = GENERATED_FILE_HEADER;
   const reExports = [];
-  for (const [exportName, item] of Object.entries(schema)) {
-    if (isRecordSchema(item)) {
-      const versioned = versionedSchemaName(exportName, version);
-      reExports.push(`export { ${versioned} as ${schemaName(exportName)} } from "./schema_v${version}.js";`);
-    } else if (isUnionSchema(item)) {
-      const versioned = versionedSchemaName(exportName, version);
-      reExports.push(`export { ${versioned} as ${schemaName(exportName)} } from "./schema_v${version}.js";`);
+  for (const [modelKey, modelDef] of Object.entries(ir.models)) {
+    if (modelDef.type === "record") {
+      const versioned = versionedSchemaName(modelKey, version);
+      reExports.push(`export { ${versioned} as ${modelKey}Schema } from "./schema_v${version}.js";`);
+    } else if (modelDef.type === "union") {
+      const versioned = versionedSchemaName(modelKey, version);
+      reExports.push(`export { ${versioned} as ${modelKey}Schema } from "./schema_v${version}.js";`);
 
       // Also re-export union variant schemas
-      for (const variantName of Object.keys(item.variants)) {
+      for (const variantName of Object.keys(modelDef.union.variants)) {
         const formattedVariant = formatVariantName(variantName);
-        const versionedVariant = `${versionedSchemaName(exportName, version)}${formattedVariant}`;
-        reExports.push(`export { ${versionedVariant} as ${`${exportName}${formattedVariant}Schema`} } from "./schema_v${version}.js";`);
+        const versionedVariant = `${versionedSchemaName(modelKey, version)}${formattedVariant}`;
+        reExports.push(`export { ${versionedVariant} as ${`${modelKey}${formattedVariant}Schema`} } from "./schema_v${version}.js";`);
       }
     }
   }
@@ -161,24 +127,22 @@ function generateSchemaReExport({
 }
 
 /**
- * Generate per-version Zod schemas from a schema definition with version chain.
- *
- * @param schema - The schema definition (initial or versioned)
- * @param minSupportedVersion - Minimum version to generate schemas for (defaults to latest)
- * @returns Object containing generated Zod schema code for each output file
+ * Generate per-version Zod schemas from an already-resolved versioned IR chain.
  */
-export function generateVersionedZodFromSchema(schema, minSupportedVersion) {
+export function generateVersionedZodFromChain(resolved, minSupportedVersion) {
+  const {
+    chain
+  } = resolved;
   const {
-    chain,
     minVersion
-  } = resolveSchemaChain(schema, minSupportedVersion);
+  } = resolveMinVersion(chain, minSupportedVersion);
   const zodSchemas = new Map();
   for (const {
     version,
-    schema: versionSchema
+    ir
   } of chain) {
     if (version < minVersion) continue;
-    zodSchemas.set(version, generateZodSchemasForVersion(version, versionSchema));
+    zodSchemas.set(version, generateZodSchemasForVersion(version, ir));
   }
   const schemaReExport = generateSchemaReExport(chain[chain.length - 1]);
   return {