@postman/sdk-config 0.11.0 → 0.12.0

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

@@ -438,6 +438,12 @@ var dependencySchema = zod.z.strictObject({
 }).refine(({ source, version }) => source !== void 0 || version !== void 0, {
   message: "dependency must define a version or a source"
 });
+var bugsSchema = zod.z.strictObject({
+  url: nonEmptyStringSchema.optional().describe("The issue tracker URL."),
+  email: nonEmptyStringSchema.optional().describe("The address for reporting issues.")
+}).refine(({ url, email }) => url !== void 0 || email !== void 0, {
+  message: "bugs must define a url or an email"
+});
 var projectUrlSchema = zod.z.strictObject({
   label: nonEmptyStringSchema.describe("The label displayed for the project link."),
   url: nonEmptyStringSchema.describe("The project link URL.")
@@ -452,6 +458,7 @@ var packageConfigSchema = zod.z.strictObject({
   description: zod.z.string().optional().describe("The package description used in generated metadata."),
   repository: nonEmptyStringSchema.optional().describe("The source repository for the generated SDK."),
   homepage: nonEmptyStringSchema.optional().describe("The package homepage URL."),
+  bugs: bugsSchema.optional().describe("Where issues with the package are reported."),
   documentationUrl: nonEmptyStringSchema.optional().describe("The package documentation URL."),
   authors: zod.z.array(authorSchema).optional().describe("Authors credited in package metadata."),
   developers: zod.z.array(developerSchema).optional().describe("Developers credited in package metadata."),
@@ -1239,6 +1246,7 @@ function githubOutput(value, publishInfo, rawOutput, language, sourcePath, state
   const reviewers = mapReviewers(value.reviewers, [...sourcePath, "reviewers"], state);
   if (type) consume(state, [...sourcePath, "type"]);
   if (typeof value.makePr === "boolean") consume(state, [...sourcePath, "makePr"]);
+  if (value.workflows === true) consume(state, [...sourcePath, "workflows"]);
   if (stringValue(value.host)) consume(state, [...sourcePath, "host"]);
   if (stringValue(value.branch)) consume(state, [...sourcePath, "branch"]);
   consumeCredentialObject(value.credentials, [...sourcePath, "credentials"], state);
@@ -2434,7 +2442,7 @@ var packageScriptSchema = zod.z.strictObject({
   command: nonEmptyStringSchema.describe("The command executed by the package script.")
 });
 var httpClientSchema = zod.z.strictObject({
-  name: zod.z.enum(["axios", "fetch"]).describe("The HTTP client used by generated TypeScript code.")
+  name: zod.z.enum(["axios", "fetch", "node-fetch"]).describe("The HTTP client used by generated TypeScript code.")
 });
 var typescriptGenerationConfigSchema = zod.z.strictObject({
   typescriptVersion: nonEmptyStringSchema.optional().describe("The TypeScript version used by the generated project."),
@@ -2450,6 +2458,37 @@ var typescriptGenerationConfigSchema = zod.z.strictObject({
   /** Name of the top-level namespace export emitted by Fern-compatible TypeScript SDKs. */
   namespaceExportName: nonEmptyStringSchema.optional().describe("The top-level namespace export name."),
   consolidateTypeFiles: zod.z.boolean().optional().describe("Whether generated types are consolidated into fewer source files."),
+  formDataSupport: zod.z.enum(["Node16", "Node18"]).optional().describe(
+    "The multipart form-data implementation: Node16 uses the form-data packages, Node18 uses the platform FormData."
+  ),
+  allowExtraFields: zod.z.boolean().optional().describe(
+    "Whether response parsing keeps unrecognized object keys and accepts unrecognized union members and enum values."
+  ),
+  generateSubpackageExports: zod.z.boolean().optional().describe(
+    "Whether the package manifest exports each subpackage client as its own entry point."
+  ),
+  exportAllRequestsAtRoot: zod.z.boolean().optional().describe("Whether every request type is also exported from the package root."),
+  generateEndpointMetadata: zod.z.boolean().optional().describe("Whether generated clients expose metadata for each endpoint."),
+  outputEsm: zod.z.boolean().optional().describe(
+    "Whether the package is marked as an ES module while still shipping its CommonJS build."
+  ),
+  neverThrowErrors: zod.z.boolean().optional().describe(
+    "Whether client methods return a wrapped response instead of throwing on a non-2xx status."
+  ),
+  includeOtherInUnionTypes: zod.z.boolean().optional().describe("Whether union types gain a member for variants the SDK does not recognize."),
+  includeUtilsOnUnionMembers: zod.z.boolean().optional().describe("Whether helper utilities are generated on each member of a union type."),
+  omitFernHeaders: zod.z.boolean().optional().describe("Whether requests omit the SDK identification headers and the User-Agent header."),
+  linter: zod.z.enum(["biome", "oxlint", "none"]).optional().describe("The linter configured in the generated project."),
+  formatter: zod.z.enum(["prettier", "biome", "oxfmt", "none"]).optional().describe("The formatter configured in the generated project."),
+  exports: jsonObjectSchema.optional().describe(
+    "package.json exports entries, keyed by subpath, applied over the generated exports. Each subpath replaces the generated one."
+  ),
+  files: zod.z.array(nonEmptyStringSchema).optional().describe("package.json files entries, listed ahead of the generated ones."),
+  engines: zod.z.record(nonEmptyStringSchema, nonEmptyStringSchema).optional().describe("package.json engines version ranges, keyed by engine name such as node."),
+  lintStaged: zod.z.record(nonEmptyStringSchema, zod.z.array(nonEmptyStringSchema).min(1)).optional().describe("lint-staged commands to run, keyed by file glob."),
+  browser: zod.z.record(nonEmptyStringSchema, zod.z.union([zod.z.boolean(), nonEmptyStringSchema])).optional().describe(
+    "package.json browser field: a module or file is excluded (false) or replaced by another path."
+  ),
   allowCustomFetcher: zod.z.boolean().optional().describe("Whether callers can supply a custom fetch implementation."),
   useBrandedStringAliases: zod.z.boolean().optional().describe("Whether string aliases are emitted as distinct branded types."),
   useLegacyExports: zod.z.boolean().optional().describe("Whether the package emits the legacy export layout."),
@@ -2865,16 +2904,21 @@ function mapFernConfigToSdkConfigV1(input) {
         ...optional("client", clients.targetOverrides[index]),
         ...optional("docs", docs.targetOverrides[index])
       };
-      const targetPackage = { ...invocation.package, ...outputPackage, ...generator.package };
+      const mappedPackage = { ...invocation.package, ...outputPackage, ...generator.package };
       invocation.unsupportedFields.push(
         ...resolveTargetPackage(
-          targetPackage,
+          mappedPackage,
           invocation.packageFallbacks,
           generator,
           output.delivery,
           index
         )
       );
+      const targetPackage = withRustCratesPublishDefaults(mappedPackage, {
+        language,
+        output,
+        generator
+      });
       if (Object.keys(targetPackage).length > 0 || outputPackage || generator.package) {
         target.package = targetPackage;
       }
@@ -2943,6 +2987,21 @@ function mapFernConfigToSdkConfigV1(input) {
     ])
   };
 }
+function withRustCratesPublishDefaults(packageConfig, { language, output, generator }) {
+  if (language !== "rust" || !("publish" in output) || output.publish?.registry !== "crates") {
+    return packageConfig;
+  }
+  const { packageName } = packageConfig;
+  return {
+    ...packageName ? { description: `Rust SDK for ${packageName} generated by Fern` } : {},
+    ...usesCustomLicenseFile(generator) ? {} : { license: { type: "MIT" } },
+    ...packageConfig
+  };
+}
+function usesCustomLicenseFile({ config, raw }) {
+  const metadata = isObject(raw) && isObject(raw.metadata) ? raw.metadata : void 0;
+  return isObject(config) && typeof config.packageLicenseFile === "string" || isObject(metadata?.license);
+}
 function resolveLanguage(generator, index) {
   const language = generator.sdkLanguage ?? generatorLanguages[generator.name];
   if (!language || !isFernLanguage(language)) {
@@ -3081,6 +3140,13 @@ function mapInvocation(generator, language, activeLanguages, index) {
     }
   }
   const docs = mapReadme(generator.readme, language, activeLanguages, state, [...prefix, "readme"]);
+  if (language === "typescript") {
+    const includeApiReference = takeBoolean(config, ["includeApiReference"], state, [
+      ...prefix,
+      "config"
+    ]);
+    if (includeApiReference !== void 0) docs.includeApiReference = includeApiReference;
+  }
   const unsupportedFields = [
     ...state.valueDiagnostics ?? [],
     ...collectUnsupported(config, [...prefix, "config"], state),
@@ -3261,7 +3327,13 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
   });
   if (Object.keys(naming).length) generation.naming = naming;
   const wireTests = takeBoolean(config, ["enableWireTests", "generateWireTests"], state, basePath);
-  if (wireTests !== void 0) generation.wireTests = { enabled: wireTests };
+  const wireTestsFallback = language === "typescript" ? takeBoolean(config, ["wireTestsFallbackToAutoGeneratedErrorExamples"], state, basePath) : void 0;
+  if (wireTests !== void 0 || wireTestsFallback !== void 0) {
+    generation.wireTests = { enabled: wireTests ?? true };
+    if (wireTestsFallback !== void 0) {
+      generation.wireTests.fallbackToGeneratedErrorExamples = wireTestsFallback;
+    }
+  }
   const webSockets = takeBoolean(
     config,
     ["generateWebSocketClients", "shouldGenerateWebsocketClients", "enableWebsockets"],
@@ -3304,10 +3376,10 @@ function mapTypescriptStreams(config, state, basePath) {
 function mapLanguageConfig(language, config, state, packageConfig, basePath, targetIndex) {
   switch (language) {
     case "typescript":
-      return mapTypescript(config, state, packageConfig, basePath);
+      return mapTypescript(config, state, packageConfig, basePath, true);
     case "mcp":
       return {
-        ...mapTypescript(config, state, packageConfig, basePath),
+        ...mapTypescript(config, state, packageConfig, basePath, false),
         ...mapMcp(config, state, basePath)
       };
     case "python":
@@ -3333,7 +3405,7 @@ function mapLanguageConfig(language, config, state, packageConfig, basePath, tar
       return mapTerraform(config, state, packageConfig, basePath);
   }
 }
-function mapTypescript(config, state, packageConfig, basePath) {
+function mapTypescript(config, state, packageConfig, basePath, sdkTarget) {
   const packageJsonManifest = mapPackageManifest(
     config,
     ["packageJson"],
@@ -3346,18 +3418,74 @@ function mapTypescript(config, state, packageConfig, basePath) {
   const packageManagerVersionPart = packageManagerAtIndex >= 0 ? packageJsonPackageManager?.slice(packageManagerAtIndex + 1).split("+")[0] : void 0;
   const packageManagerVersion = packageManagerVersionPart || void 0;
   if (packageJsonManifest) liftPackageJsonDependencies(packageJsonManifest, state, packageConfig);
+  const manifestOptions = sdkTarget && packageJsonManifest ? mapPackageManifestOptions(packageJsonManifest, state, packageConfig) : {};
   const serdeLayer = takeBoolean(config, ["serdeLayer"], state, basePath);
   const noSerdeLayer = takeBoolean(config, ["noSerdeLayer"], state, basePath);
-  const fetchSupport = takeEnum(config, ["fetchSupport"], ["native"], state, basePath);
+  const fetchSupport = takeEnum(
+    config,
+    ["fetchSupport"],
+    sdkTarget ? ["native", "node-fetch"] : ["native"],
+    state,
+    basePath
+  );
   const namingObject = takeObject(config, ["naming"], state, basePath);
   const nestedNamespace = namingObject ? takeString(namingObject.value, ["namespace"], state, namingObject.path) : void 0;
+  const sdkOnlyOptions = sdkTarget ? {
+    formDataSupport: takeEnum(
+      config,
+      ["formDataSupport"],
+      ["Node16", "Node18"],
+      state,
+      basePath
+    ),
+    allowExtraFields: takeBoolean(config, ["allowExtraFields"], state, basePath),
+    generateSubpackageExports: takeBoolean(
+      config,
+      ["generateSubpackageExports"],
+      state,
+      basePath
+    ),
+    exportAllRequestsAtRoot: takeBoolean(config, ["exportAllRequestsAtRoot"], state, basePath),
+    generateEndpointMetadata: takeBoolean(
+      config,
+      ["generateEndpointMetadata"],
+      state,
+      basePath
+    ),
+    outputEsm: takeBoolean(config, ["outputEsm"], state, basePath),
+    neverThrowErrors: takeBoolean(config, ["neverThrowErrors"], state, basePath),
+    includeOtherInUnionTypes: takeBoolean(
+      config,
+      ["includeOtherInUnionTypes"],
+      state,
+      basePath
+    ),
+    includeUtilsOnUnionMembers: takeBoolean(
+      config,
+      ["includeUtilsOnUnionMembers"],
+      state,
+      basePath
+    ),
+    omitFernHeaders: takeBoolean(config, ["omitFernHeaders"], state, basePath),
+    linter: takeEnum(config, ["linter"], ["biome", "oxlint", "none"], state, basePath),
+    formatter: takeEnum(
+      config,
+      ["formatter"],
+      ["prettier", "biome", "oxfmt", "none"],
+      state,
+      basePath
+    )
+  } : {};
   return compact({
+    ...sdkOnlyOptions,
+    // Only the manifest writes these keys; nothing in sdkOnlyOptions or below shares a name.
+    ...manifestOptions,
     typescriptVersion: takeString(config, ["typescriptVersion"], state, basePath),
     zodVersion: takeString(config, ["zodVersion"], state, basePath),
     packageManager: takeEnum(config, ["packageManager"], ["pnpm", "yarn"], state, basePath),
     packageManagerVersion,
     testFramework: takeEnum(config, ["testFramework"], ["jest", "vitest"], state, basePath),
-    httpClient: fetchSupport === "native" ? { name: "fetch" } : void 0,
+    httpClient: fetchSupport === void 0 ? void 0 : { name: fetchSupport === "native" ? "fetch" : "node-fetch" },
     bundle: takeBoolean(config, ["bundle"], state, basePath),
     exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
     namespaceExportName: takeString(config, ["namespaceExportName", "namespaceExport"], state, basePath) ?? nestedNamespace,
@@ -3754,6 +3882,83 @@ function mapPackageManifest(config, aliases, state, packageConfig, basePath) {
   );
   return manifest;
 }
+function mapPackageManifestOptions(manifest, state, packageConfig) {
+  const bugs = takeManifestBugs(manifest, state);
+  if (bugs) packageConfig.bugs = bugs;
+  const repository = takeManifestRepository(manifest, state);
+  if (repository !== void 0 && packageConfig.repository === void 0) {
+    packageConfig.repository = repository;
+  }
+  const exports = takeObject(manifest.value, ["exports"], state, manifest.path);
+  if (exports) consume(state, exports.path);
+  return compact({
+    exports: exports?.value,
+    scripts: takeManifestScripts(manifest, state),
+    files: takeStringArray(manifest.value, ["files"], state, manifest.path),
+    engines: takeManifestStringRecord(manifest, "engines", state),
+    lintStaged: takeManifestLintStaged(manifest, state),
+    browser: takeManifestBrowser(manifest, state)
+  });
+}
+function takeManifestBugs(manifest, state) {
+  const text = takeString(manifest.value, ["bugs"], state, manifest.path);
+  if (text !== void 0) return { url: text };
+  const located = takeObject(manifest.value, ["bugs"], state, manifest.path);
+  if (!located) return void 0;
+  const url = takeString(located.value, ["url"], state, located.path);
+  const email = takeString(located.value, ["email"], state, located.path);
+  return url === void 0 && email === void 0 ? void 0 : compact({ url, email });
+}
+function takeManifestRepository(manifest, state) {
+  const text = takeString(manifest.value, ["repository"], state, manifest.path);
+  if (text !== void 0) return text;
+  const located = takeObject(manifest.value, ["repository"], state, manifest.path);
+  if (!located) return void 0;
+  const url = takeString(located.value, ["url"], state, located.path);
+  if (url !== void 0) void takeEnum(located.value, ["type"], ["git"], state, located.path);
+  return url;
+}
+function takeManifestScripts(manifest, state) {
+  const located = takeObject(manifest.value, ["scripts"], state, manifest.path);
+  if (!located) return void 0;
+  const scripts = Object.entries(located.value).flatMap(([name, command]) => {
+    if (typeof command !== "string" || !command) return [];
+    consume(state, [...located.path, name]);
+    return [{ name, command }];
+  });
+  return scripts.length ? scripts : void 0;
+}
+function takeManifestStringRecord(manifest, key, state) {
+  const located = takeObject(manifest.value, [key], state, manifest.path);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).flatMap(([name, value]) => {
+    if (typeof value !== "string" || !value) return [];
+    consume(state, [...located.path, name]);
+    return [[name, value]];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function takeManifestLintStaged(manifest, state) {
+  const located = takeObject(manifest.value, ["lint-staged"], state, manifest.path);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).flatMap(([glob, commands]) => {
+    const list = typeof commands === "string" ? [commands] : stringArrayValue(commands);
+    if (!list?.length || list.some((command) => !command)) return [];
+    consume(state, [...located.path, glob]);
+    return [[glob, list]];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function takeManifestBrowser(manifest, state) {
+  const located = takeObject(manifest.value, ["browser"], state, manifest.path);
+  if (!located) return void 0;
+  const entries = Object.entries(located.value).flatMap(([name, value]) => {
+    if (typeof value !== "boolean" && (typeof value !== "string" || !value)) return [];
+    consume(state, [...located.path, name]);
+    return [[name, value]];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
 function takeManifestAuthors(manifest, state) {
   const located = locate(manifest.value, ["authors"], manifest.path);
   if (!located || !Array.isArray(located.value)) return [];