@palantir/pack.document-schema.type-gen 0.0.1-beta.1

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import yaml from "js-yaml";
+function convertFieldType(field) {
+  switch (field.type) {
+    case "array":
+      return `array<${convertFieldType(field.items)}>`;
+    case "docRef":
+      return "docRef";
+    case "double":
+      return "double";
+    case "mediaRef":
+      return "mediaRef";
+    case "objectRef":
+      return "objectRef";
+    case "optional":
+      return `optional<${convertFieldType(field.item)}>`;
+    case "ref":
+      return field.name;
+    case "string":
+      return "string";
+    case "unknown":
+      return "unknown";
+    case "userRef":
+      return "userRef";
+    default:
+      throw new Error(`Unsupported field type: ${field.type}`);
+  }
+}
+function convertRecordToYaml(recordDef) {
+  const result = {
+    fields: {}
+  };
+  if (recordDef.docs) {
+    result.docs = recordDef.docs;
+  }
+  for (const [fieldName, fieldDef] of Object.entries(recordDef.fields)) {
+    const fieldType = convertFieldType(fieldDef);
+    result.fields[fieldName] = fieldType;
+  }
+  return result;
+}
+function convertUnionToYaml(unionDef) {
+  const result = {};
+  for (const [variantName, variantRef] of Object.entries(unionDef.variants)) {
+    result[variantName] = variantRef.name;
+  }
+  return result;
+}
+export function convertSchemaToSteps(schema) {
+  const steps = [];
+  const records = {};
+  const unions = {};
+  for (const def of Object.values(schema)) {
+    switch (def.type) {
+      case "record":
+        {
+          records[def.name] = convertRecordToYaml(def);
+          break;
+        }
+      case "union":
+        {
+          unions[def.name] = convertUnionToYaml(def);
+          break;
+        }
+    }
+  }
+  if (Object.keys(records).length > 0) {
+    steps.push({
+      "add-records": records
+    });
+  }
+  if (Object.keys(unions).length > 0) {
+    steps.push({
+      "add-union": unions
+    });
+  }
+  return steps;
+}
+export function convertStepsToYamlString(steps) {
+  return yaml.dump(steps, {
+    flowLevel: -1,
+    lineWidth: -1,
+    noRefs: true,
+    quotingType: "'",
+    forceQuotes: false,
+    skipInvalid: false
+  });
+}
+//# sourceMappingURL=convertSchemaToSteps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convertSchemaToSteps.js","names":["yaml","convertFieldType","field","type","items","item","name","Error","convertRecordToYaml","recordDef","result","fields","docs","fieldName","fieldDef","Object","entries","fieldType","convertUnionToYaml","unionDef","variantName","variantRef","variants","convertSchemaToSteps","schema","steps","records","unions","def","values","keys","length","push","convertStepsToYamlString","dump","flowLevel","lineWidth","noRefs","quotingType","forceQuotes","skipInvalid"],"sources":["convertSchemaToSteps.ts"],"sourcesContent":["/*\n * Copyright 2025 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 yaml from \"js-yaml\";\nimport type { MigrationStep } from \"../steps/parseMigrationSteps.js\";\nimport type { P } from \"./validateSchemaModule.js\";\n\nfunction convertFieldType(field: P.Type): string {\n  switch (field.type) {\n    case \"array\":\n      return `array<${convertFieldType(field.items as P.Type)}>`;\n    case \"docRef\":\n      return \"docRef\";\n    case \"double\":\n      return \"double\";\n    case \"mediaRef\":\n      return \"mediaRef\";\n    case \"objectRef\":\n      return \"objectRef\";\n    case \"optional\":\n      return `optional<${convertFieldType(field.item as P.Type)}>`;\n    case \"ref\":\n      return field.name;\n    case \"string\":\n      return \"string\";\n    case \"unknown\":\n      return \"unknown\";\n    case \"userRef\":\n      return \"userRef\";\n    default:\n      field satisfies never;\n      throw new Error(`Unsupported field type: ${(field as P.Type).type}`);\n  }\n}\n\nfunction convertRecordToYaml(\n  recordDef: P.RecordDef,\n): { docs?: string; fields: Record<string, string> } {\n  const result: { docs?: string; fields: Record<string, string> } = {\n    fields: {},\n  };\n\n  if (recordDef.docs) {\n    result.docs = recordDef.docs;\n  }\n\n  for (const [fieldName, fieldDef] of Object.entries(recordDef.fields)) {\n    const fieldType = convertFieldType(fieldDef);\n    result.fields[fieldName] = fieldType;\n  }\n\n  return result;\n}\n\nfunction convertUnionToYaml(unionDef: P.UnionDef): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  for (const [variantName, variantRef] of Object.entries(unionDef.variants)) {\n    result[variantName] = variantRef.name;\n  }\n\n  return result;\n}\n\nexport function convertSchemaToSteps(schema: P.ReturnedSchema): MigrationStep[] {\n  const steps: MigrationStep[] = [];\n  const records: Record<string, { docs?: string; fields: Record<string, string> }> = {};\n  const unions: Record<string, Record<string, string>> = {};\n\n  for (const def of Object.values(schema)) {\n    switch (def.type) {\n      case \"record\": {\n        records[def.name] = convertRecordToYaml(def);\n        break;\n      }\n      case \"union\": {\n        unions[def.name] = convertUnionToYaml(def);\n        break;\n      }\n    }\n  }\n\n  if (Object.keys(records).length > 0) {\n    steps.push({ \"add-records\": records });\n  }\n\n  if (Object.keys(unions).length > 0) {\n    steps.push({ \"add-union\": unions });\n  }\n\n  return steps;\n}\n\nexport function convertStepsToYamlString(steps: MigrationStep[]): string {\n  return yaml.dump(steps, {\n    flowLevel: -1,\n    lineWidth: -1,\n    noRefs: true,\n    quotingType: \"'\",\n    forceQuotes: false,\n    skipInvalid: false,\n  });\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,235 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { formatVariantName } from "../formatVariantName.js";
+
+// Define schema types for internal use
+const SchemaDefKind = {
+  RECORD: "record",
+  UNION: "union"
+};
+const TypeKind = {
+  ANY: "any",
+  ARRAY: "array",
+  DOC_REF: "docRef",
+  DOUBLE: "double",
+  MEDIA_REF: "mediaRef",
+  OBJECT_REF: "objectRef",
+  OPTIONAL: "optional",
+  REF: "ref",
+  STRING: "string",
+  USER_REF: "userRef"
+};
+
+// Base type definition for schema fields
+
+// Type guards
+function isRecordSchema(item) {
+  return item.type === SchemaDefKind.RECORD && "name" in item && "fields" in item;
+}
+function isUnionSchema(item) {
+  return item.type === SchemaDefKind.UNION && "variants" in item && "discriminant" in item;
+}
+function isRefField(field) {
+  return field.type === TypeKind.REF && "refType" in field && "name" in field;
+}
+function isArrayField(field) {
+  return field.type === TypeKind.ARRAY && "items" in field;
+}
+function isOptionalField(field) {
+  return field.type === TypeKind.OPTIONAL && "item" in field;
+}
+function detectUsedRefTypes(schema) {
+  const refTypes = new Set();
+  function scanField(field) {
+    switch (field.type) {
+      case TypeKind.ARRAY:
+        if (isArrayField(field)) {
+          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 (isOptionalField(field)) {
+          scanField(field.item);
+        }
+        break;
+      case TypeKind.USER_REF:
+        refTypes.add("UserRef");
+        break;
+    }
+  }
+  for (const item of Object.values(schema)) {
+    if (isRecordSchema(item)) {
+      for (const field of Object.values(item.fields)) {
+        scanField(field);
+      }
+    } else if (isUnionSchema(item)) {
+      for (const variant of Object.values(item.variants)) {
+        scanField(variant);
+      }
+    }
+  }
+  return refTypes;
+}
+export function generateTypesFromSchema(schema) {
+  const runtimeSchema = schema;
+
+  // Detect which ref types are used in the schema
+  const usedRefTypes = detectUsedRefTypes(runtimeSchema);
+  let output = "// Generated TypeScript interfaces from document schema\n";
+
+  // Add conditional imports based on which ref types are used
+  if (usedRefTypes.size > 0) {
+    const refTypesList = Array.from(usedRefTypes).sort().join(", ");
+    output += `import type { ${refTypesList} } from "@pack/document-schema-model-types";\n`;
+  }
+  output += "\n";
+
+  // First pass: generate record interfaces
+  for (const [exportName, item] of Object.entries(runtimeSchema)) {
+    if (item.type === SchemaDefKind.RECORD && isRecordSchema(item)) {
+      output += generateRecordInterface(item, exportName, runtimeSchema);
+      output += "\n";
+    }
+  }
+
+  // Second pass: generate union types
+  const unionEntries = Object.entries(runtimeSchema).filter(([_, item]) => item.type === SchemaDefKind.UNION && isUnionSchema(item));
+  unionEntries.forEach(([exportName, item], i) => {
+    if (isUnionSchema(item)) {
+      const unionOutput = generateUnionType(item, exportName, runtimeSchema);
+      if (unionOutput) {
+        output += unionOutput;
+        // Only add newline if not the last union
+        if (i < unionEntries.length - 1) {
+          output += "\n";
+        }
+      }
+    }
+  });
+  return output;
+}
+function generateRecordInterface(record, exportName, schema) {
+  let output = "";
+  if (record.docs) {
+    output += `/**\n * ${record.docs}\n */\n`;
+  }
+  output += `export interface ${exportName} {\n`;
+  for (const [fieldName, fieldType] of Object.entries(record.fields)) {
+    const tsType = convertTypeToTypeScript(fieldType, schema);
+    const optional = fieldType.type === TypeKind.OPTIONAL ? "?" : "";
+    output += `  readonly ${fieldName}${optional}: ${tsType};\n`;
+  }
+  output += "}\n";
+  return output;
+}
+function generateUnionType(union, exportName, schema) {
+  let output = "";
+  const variantInterfaces = [];
+
+  // First pass: generate variant interfaces
+  for (const [variantName, variantType] of Object.entries(union.variants)) {
+    const interfaceName = `${exportName}${formatVariantName(variantName)}`;
+    variantInterfaces.push({
+      name: interfaceName,
+      discriminatorValue: variantName
+    });
+    if (variantType.type === TypeKind.REF && variantType.refType === "record") {
+      // Find the corresponding record name in the schema
+      const recordName = findRecordExportName(variantType.name, schema);
+      if (recordName) {
+        output += `export interface ${interfaceName} extends ${recordName} {\n`;
+        output += `  readonly type: "${variantName}";\n`;
+        output += "}\n\n";
+      }
+    } else {
+      // Handle value types
+      const tsType = convertTypeToTypeScript(variantType, schema);
+      output += `export interface ${interfaceName} {\n`;
+      output += `  readonly type: "${variantName}";\n`;
+      output += `  readonly value: ${tsType};\n`;
+      output += "}\n\n";
+    }
+  }
+
+  // Second pass: generate the union type
+  output += `export type ${exportName} = ${variantInterfaces.map(v => v.name).join(" | ")};\n\n`;
+
+  // Third pass: generate type guards
+  for (let i = 0; i < variantInterfaces.length; i++) {
+    const variant = variantInterfaces[i];
+    output += `export function is${variant.name}(value: ${exportName}): value is ${variant.name} {\n`;
+    output += `  return value.type === "${variant.discriminatorValue}";\n`;
+    output += "}\n\n";
+  }
+  return output;
+}
+function findRecordExportName(recordName, schema) {
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (isRecordSchema(item) && item.name === recordName) {
+      return exportName;
+    }
+  }
+  return null;
+}
+function convertTypeToTypeScript(fieldType, schema) {
+  switch (fieldType.type) {
+    case TypeKind.ANY:
+      return "any";
+    case TypeKind.ARRAY:
+      if (isArrayField(fieldType)) {
+        return `readonly ${convertTypeToTypeScript(fieldType.items, schema)}[]`;
+      }
+      return "readonly unknown[]";
+    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 (isOptionalField(fieldType)) {
+        return convertTypeToTypeScript(fieldType.item, schema);
+      }
+      return "unknown";
+    case TypeKind.REF:
+      if (isRefField(fieldType) && fieldType.refType === "record") {
+        const exportName = schema ? findRecordExportName(fieldType.name, schema) : null;
+        return exportName || (isRefField(fieldType) ? fieldType.name : "unknown");
+      } else if (isRefField(fieldType) && fieldType.refType === "union") {
+        return isRefField(fieldType) ? fieldType.name : "unknown";
+      }
+      return "unknown";
+    case TypeKind.STRING:
+      return "string";
+    case TypeKind.USER_REF:
+      return "UserRef";
+    default:
+      return "unknown";
+  }
+}
+//# sourceMappingURL=generateTypesFromSchema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateTypesFromSchema.js","names":["formatVariantName","SchemaDefKind","RECORD","UNION","TypeKind","ANY","ARRAY","DOC_REF","DOUBLE","MEDIA_REF","OBJECT_REF","OPTIONAL","REF","STRING","USER_REF","isRecordSchema","item","type","isUnionSchema","isRefField","field","isArrayField","isOptionalField","detectUsedRefTypes","schema","refTypes","Set","scanField","items","add","Object","values","fields","variant","variants","generateTypesFromSchema","runtimeSchema","usedRefTypes","output","size","refTypesList","Array","from","sort","join","exportName","entries","generateRecordInterface","unionEntries","filter","_","forEach","i","unionOutput","generateUnionType","length","record","docs","fieldName","fieldType","tsType","convertTypeToTypeScript","optional","union","variantInterfaces","variantName","variantType","interfaceName","push","name","discriminatorValue","refType","recordName","findRecordExportName","map","v"],"sources":["generateTypesFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2025 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 { ReturnedSchema, Schema } from \"@palantir/pack.schema\";\nimport { formatVariantName } from \"../formatVariantName.js\";\n\n// Define schema types for internal use\nconst SchemaDefKind = {\n  RECORD: \"record\",\n  UNION: \"union\",\n} as const;\n\nconst TypeKind = {\n  ANY: \"any\",\n  ARRAY: \"array\",\n  DOC_REF: \"docRef\",\n  DOUBLE: \"double\",\n  MEDIA_REF: \"mediaRef\",\n  OBJECT_REF: \"objectRef\",\n  OPTIONAL: \"optional\",\n  REF: \"ref\",\n  STRING: \"string\",\n  USER_REF: \"userRef\",\n} as const;\n\n// Base type definition for schema fields\ninterface BaseSchemaField {\n  readonly type: string;\n}\n\ninterface AnyField extends BaseSchemaField {\n  readonly type: typeof TypeKind.ANY;\n}\n\ninterface ArrayField extends BaseSchemaField {\n  readonly type: typeof TypeKind.ARRAY;\n  readonly items: SchemaField;\n}\n\ninterface DocRefField extends BaseSchemaField {\n  readonly type: typeof TypeKind.DOC_REF;\n}\n\ninterface DoubleField extends BaseSchemaField {\n  readonly type: typeof TypeKind.DOUBLE;\n}\n\ninterface MediaRefField extends BaseSchemaField {\n  readonly type: typeof TypeKind.MEDIA_REF;\n}\n\ninterface ObjectRefField extends BaseSchemaField {\n  readonly type: typeof TypeKind.OBJECT_REF;\n}\n\ninterface OptionalField extends BaseSchemaField {\n  readonly type: typeof TypeKind.OPTIONAL;\n  readonly item: SchemaField;\n}\n\ninterface RefField extends BaseSchemaField {\n  readonly type: typeof TypeKind.REF;\n  readonly refType: \"record\" | \"union\";\n  readonly name: string;\n}\n\ninterface StringField extends BaseSchemaField {\n  readonly type: typeof TypeKind.STRING;\n}\n\ninterface UserRefField extends BaseSchemaField {\n  readonly type: typeof TypeKind.USER_REF;\n}\n\ntype SchemaField =\n  | AnyField\n  | ArrayField\n  | DocRefField\n  | DoubleField\n  | MediaRefField\n  | ObjectRefField\n  | OptionalField\n  | RefField\n  | StringField\n  | UserRefField;\n\ninterface RuntimeSchemaRecord {\n  readonly type: typeof SchemaDefKind.RECORD;\n  readonly name: string;\n  readonly docs?: string;\n  readonly fields: Readonly<Record<string, SchemaField>>;\n  readonly ref?: RefField & {\n    readonly refType: \"record\";\n  };\n}\n\ninterface RuntimeSchemaUnion {\n  readonly type: typeof SchemaDefKind.UNION;\n  readonly name?: string;\n  readonly variants: Readonly<Record<string, SchemaField>>;\n  readonly discriminant: string;\n  readonly ref?: RefField & {\n    readonly refType: \"union\";\n  };\n}\n\ntype RuntimeSchemaItem = RuntimeSchemaRecord | RuntimeSchemaUnion;\ntype RuntimeSchema = Record<string, RuntimeSchemaItem>;\n\n// Type guards\nfunction isRecordSchema(item: RuntimeSchemaItem): item is RuntimeSchemaRecord {\n  return item.type === SchemaDefKind.RECORD && \"name\" in item && \"fields\" in item;\n}\n\nfunction isUnionSchema(item: RuntimeSchemaItem): item is RuntimeSchemaUnion {\n  return item.type === SchemaDefKind.UNION && \"variants\" in item && \"discriminant\" in item;\n}\n\nfunction isRefField(field: SchemaField): field is RefField {\n  return field.type === TypeKind.REF && \"refType\" in field && \"name\" in field;\n}\n\nfunction isArrayField(field: SchemaField): field is ArrayField {\n  return field.type === TypeKind.ARRAY && \"items\" in field;\n}\n\nfunction isOptionalField(field: SchemaField): field is OptionalField {\n  return field.type === TypeKind.OPTIONAL && \"item\" in field;\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 (isArrayField(field)) {\n          scanField(field.items);\n        }\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 (isOptionalField(field)) {\n          scanField(field.item);\n        }\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 field of Object.values(item.fields)) {\n        scanField(field);\n      }\n    } else if (isUnionSchema(item)) {\n      for (const variant of Object.values(item.variants)) {\n        scanField(variant);\n      }\n    }\n  }\n\n  return refTypes;\n}\n\nexport function generateTypesFromSchema<T extends ReturnedSchema>(\n  schema: Schema<T>,\n): string {\n  const runtimeSchema = schema as unknown as RuntimeSchema;\n\n  // Detect which ref types are used in the schema\n  const usedRefTypes = detectUsedRefTypes(runtimeSchema);\n\n  let output = \"// Generated TypeScript interfaces from document schema\\n\";\n\n  // Add conditional imports based on which ref types are used\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output += `import type { ${refTypesList} } from \"@pack/document-schema-model-types\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // First pass: generate record interfaces\n  for (const [exportName, item] of Object.entries(runtimeSchema)) {\n    if (item.type === SchemaDefKind.RECORD && isRecordSchema(item)) {\n      output += generateRecordInterface(item, exportName, runtimeSchema);\n      output += \"\\n\";\n    }\n  }\n\n  // Second pass: generate union types\n  const unionEntries = Object.entries(runtimeSchema).filter(\n    ([_, item]) => item.type === SchemaDefKind.UNION && isUnionSchema(item),\n  );\n\n  unionEntries.forEach(([exportName, item], i) => {\n    if (isUnionSchema(item)) {\n      const unionOutput = generateUnionType(item, exportName, runtimeSchema);\n      if (unionOutput) {\n        output += unionOutput;\n        // Only add newline if not the last union\n        if (i < unionEntries.length - 1) {\n          output += \"\\n\";\n        }\n      }\n    }\n  });\n\n  return output;\n}\n\nfunction generateRecordInterface(\n  record: RuntimeSchemaRecord,\n  exportName: string,\n  schema: RuntimeSchema,\n): string {\n  let output = \"\";\n\n  if (record.docs) {\n    output += `/**\\n * ${record.docs}\\n */\\n`;\n  }\n\n  output += `export interface ${exportName} {\\n`;\n\n  for (const [fieldName, fieldType] of Object.entries(record.fields)) {\n    const tsType = convertTypeToTypeScript(fieldType, schema);\n    const optional = fieldType.type === TypeKind.OPTIONAL ? \"?\" : \"\";\n    output += `  readonly ${fieldName}${optional}: ${tsType};\\n`;\n  }\n\n  output += \"}\\n\";\n\n  return output;\n}\n\nfunction generateUnionType(\n  union: RuntimeSchemaUnion,\n  exportName: string,\n  schema: RuntimeSchema,\n): string {\n  let output = \"\";\n  const variantInterfaces: Array<{ name: string; discriminatorValue: string }> = [];\n\n  // First pass: generate variant interfaces\n  for (const [variantName, variantType] of Object.entries(union.variants)) {\n    const interfaceName = `${exportName}${formatVariantName(variantName)}`;\n    variantInterfaces.push({ name: interfaceName, discriminatorValue: variantName });\n\n    if (variantType.type === TypeKind.REF && variantType.refType === \"record\") {\n      // Find the corresponding record name in the schema\n      const recordName = findRecordExportName(variantType.name, schema);\n      if (recordName) {\n        output += `export interface ${interfaceName} extends ${recordName} {\\n`;\n        output += `  readonly type: \"${variantName}\";\\n`;\n        output += \"}\\n\\n\";\n      }\n    } else {\n      // Handle value types\n      const tsType = convertTypeToTypeScript(variantType, schema);\n      output += `export interface ${interfaceName} {\\n`;\n      output += `  readonly type: \"${variantName}\";\\n`;\n      output += `  readonly value: ${tsType};\\n`;\n      output += \"}\\n\\n\";\n    }\n  }\n\n  // Second pass: generate the union type\n  output += `export type ${exportName} = ${variantInterfaces.map(v => v.name).join(\" | \")};\\n\\n`;\n\n  // Third pass: generate type guards\n  for (let i = 0; i < variantInterfaces.length; i++) {\n    const variant = variantInterfaces[i]!;\n    output +=\n      `export function is${variant.name}(value: ${exportName}): value is ${variant.name} {\\n`;\n    output += `  return value.type === \"${variant.discriminatorValue}\";\\n`;\n    output += \"}\\n\\n\";\n  }\n\n  return output;\n}\n\nfunction findRecordExportName(\n  recordName: string,\n  schema: RuntimeSchema,\n): string | null {\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item) && item.name === recordName) {\n      return exportName;\n    }\n  }\n  return null;\n}\n\nfunction convertTypeToTypeScript(\n  fieldType: SchemaField,\n  schema?: RuntimeSchema,\n): string {\n  switch (fieldType.type) {\n    case TypeKind.ANY:\n      return \"any\";\n    case TypeKind.ARRAY:\n      if (isArrayField(fieldType)) {\n        return `readonly ${convertTypeToTypeScript(fieldType.items, schema)}[]`;\n      }\n      return \"readonly unknown[]\";\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 (isOptionalField(fieldType)) {\n        return convertTypeToTypeScript(fieldType.item, schema);\n      }\n      return \"unknown\";\n    case TypeKind.REF:\n      if (isRefField(fieldType) && fieldType.refType === \"record\") {\n        const exportName = schema ? findRecordExportName(fieldType.name, schema) : null;\n        return exportName || (isRefField(fieldType) ? fieldType.name : \"unknown\");\n      } else if (isRefField(fieldType) && fieldType.refType === \"union\") {\n        return isRefField(fieldType) ? fieldType.name : \"unknown\";\n      }\n      return \"unknown\";\n    case TypeKind.STRING:\n      return \"string\";\n    case TypeKind.USER_REF:\n      return \"UserRef\";\n    default:\n      fieldType satisfies never;\n      return \"unknown\";\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { generateZodSchemasFromIr } from "../ir/generateZodSchemasFromIr.js";
+import { convertSchemaToIr } from "../steps/convertStepsToIr.js";
+
+/**
+ * Generates Zod schemas from a built Schema object
+ * @param schema - Schema object built using document-schema-api
+ * @param metadata - Optional schema metadata overrides
+ * @returns Generated TypeScript code with Zod schemas
+ */
+export async function generateZodFromSchema(schema, metadata) {
+  const irSchema = convertSchemaToIr(schema, metadata);
+  const generatedCode = await generateZodSchemasFromIr(irSchema);
+  return generatedCode;
+}
+//# sourceMappingURL=generateZodFromSchema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateZodFromSchema.js","names":["generateZodSchemasFromIr","convertSchemaToIr","generateZodFromSchema","schema","metadata","irSchema","generatedCode"],"sources":["generateZodFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2025 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 { ReturnedSchema, Schema } from \"@palantir/pack.schema\";\nimport { generateZodSchemasFromIr } from \"../ir/generateZodSchemasFromIr.js\";\nimport { convertSchemaToIr, type SchemaMetadata } from \"../steps/convertStepsToIr.js\";\n\n/**\n * Generates Zod schemas from a built Schema object\n * @param schema - Schema object built using document-schema-api\n * @param metadata - Optional schema metadata overrides\n * @returns Generated TypeScript code with Zod schemas\n */\nexport async function generateZodFromSchema<T extends ReturnedSchema>(\n  schema: Schema<T>,\n  metadata?: SchemaMetadata,\n): Promise<string> {\n  const irSchema = convertSchemaToIr(\n    schema,\n    metadata,\n  );\n\n  const generatedCode = await generateZodSchemasFromIr(irSchema);\n  return generatedCode;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,SAASA,wBAAwB,QAAQ,mCAAmC;AAC5E,SAASC,iBAAiB,QAA6B,8BAA8B;;AAErF;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,qBAAqBA,CACzCC,MAAiB,EACjBC,QAAyB,EACR;EACjB,MAAMC,QAAQ,GAAGJ,iBAAiB,CAChCE,MAAM,EACNC,QACF,CAAC;EAED,MAAME,aAAa,GAAG,MAAMN,wBAAwB,CAACK,QAAQ,CAAC;EAC9D,OAAOC,aAAa;AACtB","ignoreList":[]}

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

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { z } from "zod";
+
+// Re-export types from document-schema-api
+
+// Create a deep validation schema for P.Type
+const typeSchema = z.lazy(() => z.union([z.object({
+  type: z.literal("string")
+}), z.object({
+  type: z.literal("double")
+}), z.object({
+  type: z.literal("unknown")
+}), z.object({
+  type: z.literal("ref"),
+  refType: z.enum(["record", "union"]),
+  name: z.string()
+}), z.object({
+  type: z.literal("array"),
+  items: typeSchema
+}), z.object({
+  type: z.literal("optional"),
+  item: typeSchema
+})]));
+
+// RecordDef validation schema
+const recordDefSchema = z.object({
+  type: z.literal("record"),
+  name: z.string(),
+  docs: z.string().optional(),
+  fields: z.record(z.string(), typeSchema)
+});
+
+// UnionDef validation schema
+const unionDefSchema = z.object({
+  type: z.literal("union"),
+  name: z.string(),
+  docs: z.string().optional(),
+  discriminant: z.string(),
+  variants: z.record(z.string(), z.object({
+    type: z.literal("ref"),
+    refType: z.enum(["record", "union"]),
+    name: z.string()
+  }))
+});
+
+// Schema definition (RecordDef or UnionDef)
+const schemaDefSchema = z.union([recordDefSchema, unionDefSchema]);
+
+// ReturnedSchema is a record of schema definitions
+const returnedSchemaSchema = z.record(z.string(), schemaDefSchema);
+
+// Schema module export pattern - must have default export
+const schemaModuleSchema = z.object({
+  default: returnedSchemaSchema
+}).catchall(z.unknown());
+
+/**
+ * Validates that a schema module export contains valid schema definitions
+ */
+export function validateSchemaModule(schemaModule) {
+  return schemaModuleSchema.parse(schemaModule);
+}
+
+/**
+ * Validates and extracts a schema from a module export
+ */
+export function extractValidSchema(schemaModule) {
+  const validatedModule = validateSchemaModule(schemaModule);
+  return validatedModule.default;
+}
+
+/**
+ * Type guard for P.Type validation
+ */
+export function validateSchemaType(value) {
+  return typeSchema.parse(value);
+}
+
+/**
+ * Type guard for RecordDef validation
+ */
+export function validateRecordDef(value) {
+  return recordDefSchema.parse(value);
+}
+
+/**
+ * Type guard for UnionDef validation
+ */
+export function validateUnionDef(value) {
+  return unionDefSchema.parse(value);
+}
+//# sourceMappingURL=validateSchemaModule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateSchemaModule.js","names":["z","typeSchema","lazy","union","object","type","literal","refType","enum","name","string","items","item","recordDefSchema","docs","optional","fields","record","unionDefSchema","discriminant","variants","schemaDefSchema","returnedSchemaSchema","schemaModuleSchema","default","catchall","unknown","validateSchemaModule","schemaModule","parse","extractValidSchema","validatedModule","validateSchemaType","value","validateRecordDef","validateUnionDef"],"sources":["validateSchemaModule.ts"],"sourcesContent":["/*\n * Copyright 2025 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 * as P from \"@palantir/pack.schema\";\nimport { z } from \"zod\";\n\n// Re-export types from document-schema-api\nexport type * as P from \"@palantir/pack.schema\";\nexport type SchemaDef = P.RecordDef | P.UnionDef;\nexport type ReturnedSchema = Record<string, SchemaDef>;\n\n// Create a deep validation schema for P.Type\nconst typeSchema: z.ZodType<P.Type> = z.lazy(() =>\n  z.union([\n    z.object({ type: z.literal(\"string\") }),\n    z.object({ type: z.literal(\"double\") }),\n    z.object({ type: z.literal(\"unknown\") }),\n    z.object({\n      type: z.literal(\"ref\"),\n      refType: z.enum([\"record\", \"union\"]),\n      name: z.string(),\n    }),\n    z.object({\n      type: z.literal(\"array\"),\n      items: typeSchema,\n    }),\n    z.object({\n      type: z.literal(\"optional\"),\n      item: typeSchema,\n    }),\n  ])\n);\n\n// RecordDef validation schema\nconst recordDefSchema: z.ZodType<P.RecordDef> = z.object({\n  type: z.literal(\"record\"),\n  name: z.string(),\n  docs: z.string().optional(),\n  fields: z.record(z.string(), typeSchema),\n});\n\n// UnionDef validation schema\nconst unionDefSchema: z.ZodType<P.UnionDef> = z.object({\n  type: z.literal(\"union\"),\n  name: z.string(),\n  docs: z.string().optional(),\n  discriminant: z.string(),\n  variants: z.record(\n    z.string(),\n    z.object({\n      type: z.literal(\"ref\"),\n      refType: z.enum([\"record\", \"union\"]),\n      name: z.string(),\n    }),\n  ),\n});\n\n// Schema definition (RecordDef or UnionDef)\nconst schemaDefSchema: z.ZodType<SchemaDef> = z.union([\n  recordDefSchema,\n  unionDefSchema,\n]);\n\n// ReturnedSchema is a record of schema definitions\nconst returnedSchemaSchema: z.ZodType<ReturnedSchema> = z.record(z.string(), schemaDefSchema);\n\n// Schema module export pattern - must have default export\nconst schemaModuleSchema = z.object({\n  default: returnedSchemaSchema,\n}).catchall(z.unknown());\n\n/**\n * Validates that a schema module export contains valid schema definitions\n */\nexport function validateSchemaModule(schemaModule: unknown): Record<string, unknown> {\n  return schemaModuleSchema.parse(schemaModule);\n}\n\n/**\n * Validates and extracts a schema from a module export\n */\nexport function extractValidSchema(schemaModule: unknown): ReturnedSchema {\n  const validatedModule = validateSchemaModule(schemaModule);\n  return validatedModule.default as ReturnedSchema;\n}\n\n/**\n * Type guard for P.Type validation\n */\nexport function validateSchemaType(value: unknown): P.Type {\n  return typeSchema.parse(value);\n}\n\n/**\n * Type guard for RecordDef validation\n */\nexport function validateRecordDef(value: unknown): P.RecordDef {\n  return recordDefSchema.parse(value);\n}\n\n/**\n * Type guard for UnionDef validation\n */\nexport function validateUnionDef(value: unknown): P.UnionDef {\n  return unionDefSchema.parse(value);\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/steps/__tests__/__snapshots__/stepSchemas/simpleSteps.js

@@ -0,0 +1,84 @@
+const schema = {
+  "ObjectNode": {
+    "type": "record",
+    "name": "ObjectNode",
+    "fields": {
+      "x": {
+        "type": "double"
+      },
+      "y": {
+        "type": "double"
+      },
+      "object": {
+        "type": "string"
+      },
+      "label": {
+        "type": "optional",
+        "item": {
+          "type": "string"
+        }
+      },
+      "edges": {
+        "type": "array",
+        "items": {
+          "type": "ref",
+          "refType": "record",
+          "name": "Edge"
+        }
+      }
+    },
+    "docs": "A node in the graph"
+  },
+  "TextBox": {
+    "type": "record",
+    "name": "TextBox",
+    "fields": {
+      "x": {
+        "type": "double"
+      },
+      "y": {
+        "type": "double"
+      },
+      "text": {
+        "type": "string"
+      }
+    },
+    "docs": "A text box in the graph"
+  },
+  "Edge": {
+    "type": "record",
+    "name": "Edge",
+    "fields": {
+      "source": {
+        "type": "ref",
+        "refType": "record",
+        "name": "ObjectNode"
+      },
+      "target": {
+        "type": "ref",
+        "refType": "record",
+        "name": "ObjectNode"
+      }
+    },
+    "docs": "An edge in the graph"
+  },
+  "Node": {
+    "type": "union",
+    "name": "Node",
+    "variants": {
+      "object": {
+        "type": "ref",
+        "name": "ObjectNode",
+        "refType": "record"
+      },
+      "textBox": {
+        "type": "ref",
+        "name": "TextBox",
+        "refType": "record"
+      }
+    },
+    "discriminant": "type"
+  }
+};
+export default schema;
+//# sourceMappingURL=simpleSteps.js.map

package/build/esm/utils/steps/__tests__/__snapshots__/stepSchemas/simpleSteps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleSteps.js","names":["schema"],"sources":["simpleSteps.ts"],"sourcesContent":["\nimport { Schema } from \"@palantir/pack.schema\";\n\nconst schema = (\n{\n  \"ObjectNode\": {\n    \"type\": \"record\",\n    \"name\": \"ObjectNode\",\n    \"fields\": {\n      \"x\": {\n        \"type\": \"double\"\n      },\n      \"y\": {\n        \"type\": \"double\"\n      },\n      \"object\": {\n        \"type\": \"string\"\n      },\n      \"label\": {\n        \"type\": \"optional\",\n        \"item\": {\n          \"type\": \"string\"\n        }\n      },\n      \"edges\": {\n        \"type\": \"array\",\n        \"items\": {\n          \"type\": \"ref\",\n          \"refType\": \"record\",\n          \"name\": \"Edge\"\n        }\n      }\n    },\n    \"docs\": \"A node in the graph\"\n  },\n  \"TextBox\": {\n    \"type\": \"record\",\n    \"name\": \"TextBox\",\n    \"fields\": {\n      \"x\": {\n        \"type\": \"double\"\n      },\n      \"y\": {\n        \"type\": \"double\"\n      },\n      \"text\": {\n        \"type\": \"string\"\n      }\n    },\n    \"docs\": \"A text box in the graph\"\n  },\n  \"Edge\": {\n    \"type\": \"record\",\n    \"name\": \"Edge\",\n    \"fields\": {\n      \"source\": {\n        \"type\": \"ref\",\n        \"refType\": \"record\",\n        \"name\": \"ObjectNode\"\n      },\n      \"target\": {\n        \"type\": \"ref\",\n        \"refType\": \"record\",\n        \"name\": \"ObjectNode\"\n      }\n    },\n    \"docs\": \"An edge in the graph\"\n  },\n  \"Node\": {\n    \"type\": \"union\",\n    \"name\": \"Node\",\n    \"variants\": {\n      \"object\": {\n        \"type\": \"ref\",\n        \"name\": \"ObjectNode\",\n        \"refType\": \"record\"\n      },\n      \"textBox\": {\n        \"type\": \"ref\",\n        \"name\": \"TextBox\",\n        \"refType\": \"record\"\n      }\n    },\n    \"discriminant\": \"type\"\n  }\n}\n) satisfies Schema<any>;\n\nexport default schema;\n"],"mappings":"AAGA,MAAMA,MAAM,GACZ;EACE,YAAY,EAAE;IACZ,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,YAAY;IACpB,QAAQ,EAAE;MACR,GAAG,EAAE;QACH,MAAM,EAAE;MACV,CAAC;MACD,GAAG,EAAE;QACH,MAAM,EAAE;MACV,CAAC;MACD,QAAQ,EAAE;QACR,MAAM,EAAE;MACV,CAAC;MACD,OAAO,EAAE;QACP,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE;UACN,MAAM,EAAE;QACV;MACF,CAAC;MACD,OAAO,EAAE;QACP,MAAM,EAAE,OAAO;QACf,OAAO,EAAE;UACP,MAAM,EAAE,KAAK;UACb,SAAS,EAAE,QAAQ;UACnB,MAAM,EAAE;QACV;MACF;IACF,CAAC;IACD,MAAM,EAAE;EACV,CAAC;EACD,SAAS,EAAE;IACT,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,SAAS;IACjB,QAAQ,EAAE;MACR,GAAG,EAAE;QACH,MAAM,EAAE;MACV,CAAC;MACD,GAAG,EAAE;QACH,MAAM,EAAE;MACV,CAAC;MACD,MAAM,EAAE;QACN,MAAM,EAAE;MACV;IACF,CAAC;IACD,MAAM,EAAE;EACV,CAAC;EACD,MAAM,EAAE;IACN,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE;MACR,QAAQ,EAAE;QACR,MAAM,EAAE,KAAK;QACb,SAAS,EAAE,QAAQ;QACnB,MAAM,EAAE;MACV,CAAC;MACD,QAAQ,EAAE;QACR,MAAM,EAAE,KAAK;QACb,SAAS,EAAE,QAAQ;QACnB,MAAM,EAAE;MACV;IACF,CAAC;IACD,MAAM,EAAE;EACV,CAAC;EACD,MAAM,EAAE;IACN,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,MAAM;IACd,UAAU,EAAE;MACV,QAAQ,EAAE;QACR,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,YAAY;QACpB,SAAS,EAAE;MACb,CAAC;MACD,SAAS,EAAE;QACT,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE;MACb;IACF,CAAC;IACD,cAAc,EAAE;EAClB;AACF,CACuB;AAEvB,eAAeA,MAAM","ignoreList":[]}

package/build/esm/utils/steps/__tests__/__snapshots__/types/arrayFields.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=arrayFields.js.map

package/build/esm/utils/steps/__tests__/__snapshots__/types/arrayFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayFields.js","names":[],"sources":["arrayFields.ts"],"sourcesContent":["// Generated TypeScript interfaces from document schema\n\nexport interface Container {\n  readonly items: readonly string[];\n  readonly numbers: readonly number[];\n}\n\n"],"mappings":"","ignoreList":[]}