@postman/sdk-config 0.5.1 → 0.7.0

package/dist/sdk-config-ir/index.cjs

@@ -468,17 +468,22 @@ var typescriptGenerationConfigSchema = zod.z.strictObject({
   compilerOptions: compilerOptionsSchema.optional(),
   httpClient: httpClientSchema.optional(),
   packageManager: zod.z.enum(["pnpm", "yarn"]).optional(),
+  /** e.g. `1.22.22` — from the customer's own `config.packageJson.packageManager` (`yarn@1.22.22`). */
+  packageManagerVersion: nonEmptyStringSchema.optional(),
   testFramework: zod.z.enum(["jest", "vitest"]).optional(),
   namingStrategy: zod.z.enum(["base", "originalPropertyNames"]).optional(),
   bundle: zod.z.boolean().optional(),
   exportClassDefault: zod.z.boolean().optional(),
   /** Name of the top-level namespace export emitted by Fern-compatible TypeScript SDKs. */
   namespaceExportName: nonEmptyStringSchema.optional(),
+  consolidateTypeFiles: zod.z.boolean().optional(),
   allowCustomFetcher: zod.z.boolean().optional(),
   useBrandedStringAliases: zod.z.boolean().optional(),
   useLegacyExports: zod.z.boolean().optional(),
   useBigInt: zod.z.boolean().optional(),
   serdeLayer: zod.z.boolean().optional(),
+  /** Ship only the ESM build (drops CJS) to avoid the Node dual-package hazard. */
+  esmOnly: zod.z.boolean().optional(),
   scripts: zod.z.array(packageScriptSchema).optional()
 });
 
@@ -1204,6 +1209,151 @@ var sdkConfigIrV1Schema = zod.z.strictObject({
 function parseSdkConfigIrV1(value) {
   return sdkConfigIrV1Schema.parse(value);
 }
+var OMIT = /* @__PURE__ */ Symbol("omit");
+function inputJsonSchema(schema) {
+  return zod.z.toJSONSchema(schema, {
+    io: "input",
+    unrepresentable: "any"
+  });
+}
+function stripUnknownProperties(value, schema) {
+  return project(value, schema, schema, false);
+}
+function omitSchemaDefaults(value, schema) {
+  const projected = project(value, schema, schema, true);
+  return projected === OMIT ? void 0 : projected;
+}
+function project(value, candidateSchema, rootSchema, omitDefaults) {
+  const resolvedCandidate = resolveSchema(candidateSchema, rootSchema);
+  if (omitDefaults && Object.hasOwn(resolvedCandidate, "default") && deepEqual(value, resolvedCandidate.default)) {
+    return OMIT;
+  }
+  const schema = selectSchema(value, resolvedCandidate, rootSchema);
+  if (omitDefaults && schema !== resolvedCandidate && Object.hasOwn(schema, "default") && deepEqual(value, schema.default)) {
+    return OMIT;
+  }
+  if (Array.isArray(value)) {
+    if (!schema.items) return value;
+    return value.map((item) => {
+      const projected = project(item, schema.items, rootSchema, omitDefaults);
+      return projected === OMIT ? item : projected;
+    });
+  }
+  if (!isRecord(value) || schema.type !== "object") return value;
+  const entries = [];
+  const properties = schema.properties ?? {};
+  const unionProperties = omitDefaults ? properties : collectAlternativeProperties(resolvedCandidate, rootSchema);
+  for (const [key, propertySchema] of Object.entries(properties)) {
+    if (!Object.hasOwn(value, key)) continue;
+    const projected = project(value[key], propertySchema, rootSchema, omitDefaults);
+    if (projected !== OMIT) entries.push([key, projected]);
+  }
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (Object.hasOwn(properties, key)) continue;
+    if (Object.hasOwn(unionProperties, key)) {
+      entries.push([key, fieldValue]);
+      continue;
+    }
+    if (schema.additionalProperties !== false) {
+      const projected = typeof schema.additionalProperties === "object" ? project(fieldValue, schema.additionalProperties, rootSchema, omitDefaults) : fieldValue;
+      if (projected !== OMIT) entries.push([key, projected]);
+    } else if (omitDefaults) {
+      throw new Error(`Cannot serialize property unknown to the wire schema: ${key}`);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function collectAlternativeProperties(schema, rootSchema) {
+  const alternatives = schema.oneOf ?? schema.anyOf;
+  if (!alternatives) return schema.properties ?? {};
+  return Object.assign(
+    {},
+    ...alternatives.map((alternative) => resolveSchema(alternative, rootSchema).properties ?? {})
+  );
+}
+function selectSchema(value, schema, rootSchema) {
+  const alternatives = schema.oneOf ?? schema.anyOf;
+  if (!alternatives || alternatives.length === 0) return schema;
+  const best = alternatives.map((alternative, index) => {
+    const resolved = resolveSchema(alternative, rootSchema);
+    return { index, schema: resolved, score: schemaMatchScore(value, resolved) };
+  }).sort((left, right) => right.score - left.score || left.index - right.index)[0];
+  return best.score === Number.NEGATIVE_INFINITY ? schema : best.schema;
+}
+function schemaMatchScore(value, schema) {
+  if (Object.hasOwn(schema, "const") && !deepEqual(value, schema.const)) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (schema.enum && !schema.enum.some((candidate) => deepEqual(value, candidate))) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (schema.type === "object") {
+    if (!isRecord(value)) return Number.NEGATIVE_INFINITY;
+    const properties = schema.properties ?? {};
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (!Object.hasOwn(value, key)) continue;
+      if (Object.hasOwn(propertySchema, "const") && !deepEqual(value[key], propertySchema.const)) {
+        return Number.NEGATIVE_INFINITY;
+      }
+    }
+    return Object.keys(value).filter((key) => Object.hasOwn(properties, key)).length;
+  }
+  if (schema.type === "array") return Array.isArray(value) ? 1 : Number.NEGATIVE_INFINITY;
+  if (schema.type === "string") return typeof value === "string" ? 1 : Number.NEGATIVE_INFINITY;
+  if (schema.type === "number" || schema.type === "integer") {
+    return typeof value === "number" ? 1 : Number.NEGATIVE_INFINITY;
+  }
+  if (schema.type === "boolean") return typeof value === "boolean" ? 1 : Number.NEGATIVE_INFINITY;
+  if (schema.type === "null") return value === null ? 1 : Number.NEGATIVE_INFINITY;
+  return 0;
+}
+function resolveSchema(schema, rootSchema) {
+  if (!schema.$ref) return schema;
+  if (!schema.$ref.startsWith("#/$defs/")) return schema;
+  const name = schema.$ref.slice("#/$defs/".length).replaceAll("~1", "/").replaceAll("~0", "~");
+  return rootSchema.$defs?.[name] ?? schema;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => deepEqual(value, right[index]));
+  }
+  if (isRecord(left) && isRecord(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && deepEqual(left[key], right[key]));
+  }
+  return false;
+}
+
+// src/sdk-config-ir/v1/wire.ts
+var sdkConfigIrCapabilitySchema = zod.z.enum(["generation.generateFullProject"]);
+var sdkConfigIrV1InputJsonSchema = inputJsonSchema(sdkConfigIrV1Schema);
+function serializeSdkConfigIrV1(value) {
+  const parsed = parseSdkConfigIrV1(value);
+  const wireValue = omitSchemaDefaults(parsed, sdkConfigIrV1InputJsonSchema);
+  const requiredCapabilities = [];
+  if (wireValue === void 0) {
+    throw new Error("SDK Config IR v1 root cannot be omitted from its wire payload");
+  }
+  if (parsed.generation.generateFullProject) {
+    requiredCapabilities.push("generation.generateFullProject");
+  }
+  const json = JSON.stringify(wireValue);
+  if (json === void 0) {
+    throw new Error("SDK Config IR v1 could not be serialized as JSON");
+  }
+  return {
+    body: new TextEncoder().encode(json),
+    requiredCapabilities
+  };
+}
+function parseSdkConfigIrV1ForConsumption(value) {
+  return parseSdkConfigIrV1(stripUnknownProperties(value, sdkConfigIrV1InputJsonSchema));
+}
 
 exports.SDK_CONFIG_IR_V1_SCHEMA_VERSION = SDK_CONFIG_IR_V1_SCHEMA_VERSION;
 exports.apiConfigSchema = apiConfigSchema;
@@ -1235,6 +1385,7 @@ exports.nonEmptyStringSchema = nonEmptyStringSchema;
 exports.outputConfigSchema = outputConfigSchema;
 exports.packageConfigSchema = packageConfigSchema;
 exports.parseSdkConfigIrV1 = parseSdkConfigIrV1;
+exports.parseSdkConfigIrV1ForConsumption = parseSdkConfigIrV1ForConsumption;
 exports.phpGenerationConfigSchema = phpGenerationConfigSchema;
 exports.publishConfigSchema = publishConfigSchema;
 exports.publishRegistrySchema = publishRegistrySchema;
@@ -1245,7 +1396,9 @@ exports.relativePathSchema = relativePathSchema;
 exports.replayConfigSchema = replayConfigSchema;
 exports.rubyGenerationConfigSchema = rubyGenerationConfigSchema;
 exports.rustGenerationConfigSchema = rustGenerationConfigSchema;
+exports.sdkConfigIrCapabilitySchema = sdkConfigIrCapabilitySchema;
 exports.sdkConfigIrV1Schema = sdkConfigIrV1Schema;
+exports.serializeSdkConfigIrV1 = serializeSdkConfigIrV1;
 exports.sourceConfigSchema = sourceConfigSchema;
 exports.sourceSpecConfigSchema = sourceSpecConfigSchema;
 exports.sourceSpecTypeSchema = sourceSpecTypeSchema;