@postman/sdk-config 0.3.1 → 0.3.3

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

@@ -286,7 +286,8 @@ var composerPackageNameSchema = nonEmptyStringSchema.regex(
 );
 var authorSchema = z.strictObject({
   name: nonEmptyStringSchema,
-  email: z.email().optional()
+  email: z.email().optional(),
+  url: nonEmptyStringSchema.optional()
 });
 var developerSchema = z.strictObject({
   name: nonEmptyStringSchema,
@@ -705,6 +706,7 @@ function githubOutput(value, publishInfo, language, sourcePath, state, index) {
   if (typeof value.makePr === "boolean") consume(state, [...sourcePath, "makePr"]);
   if (stringValue(value.host)) consume(state, [...sourcePath, "host"]);
   if (stringValue(value.branch)) consume(state, [...sourcePath, "branch"]);
+  const credentials = mapCredentials(value.credentials, [...sourcePath, "credentials"], state);
   return {
     output: {
       delivery: "github",
@@ -713,13 +715,58 @@ function githubOutput(value, publishInfo, language, sourcePath, state, index) {
         ...optional("host", stringValue(value.host)),
         ...optional("branch", stringValue(value.branch)),
         mode: value.makePr === true || type === "pullRequest" ? "pull-request" : type === "push" ? "push" : "release",
-        ...optional("reviewers", reviewers)
+        ...optional("reviewers", reviewers),
+        ...optional("credentials", credentials)
       },
       ...publication ? { publish: publication.publish } : {}
     },
     ...optional("package", publication?.package)
   };
 }
+function mapCredentials(value, sourcePath, state) {
+  if (!isObject(value)) return void 0;
+  return credentialsFromObject(value, sourcePath, state);
+}
+function mapInlineCredentials(value, sourcePath, state) {
+  const credentials = mapCredentials(value.credentials, [...sourcePath, "credentials"], state);
+  if (credentials) return credentials;
+  return credentialsFromObject(value, sourcePath, state);
+}
+function credentialsFromObject(value, sourcePath, state) {
+  const credentials = {};
+  const username = stringValue(value.username);
+  const password = stringValue(value.password);
+  const token = stringValue(value.token);
+  const apiKey = stringValue(value.apiKey);
+  if (username) {
+    credentials.username = username;
+    consume(state, [...sourcePath, "username"]);
+  }
+  if (password) {
+    credentials.password = password;
+    consume(state, [...sourcePath, "password"]);
+  }
+  if (token) {
+    credentials.token = token;
+    consume(state, [...sourcePath, "token"]);
+  }
+  if (apiKey) {
+    credentials.apiKey = apiKey;
+    consume(state, [...sourcePath, "apiKey"]);
+  }
+  return Object.keys(credentials).length === 0 ? void 0 : credentials;
+}
+function mapMavenSignature(value, sourcePath, state) {
+  if (!isObject(value)) return void 0;
+  const keyId = stringValue(value.keyId);
+  const password = stringValue(value.password);
+  const secretKey = stringValue(value.secretKey);
+  if (!keyId || !password || !secretKey) return void 0;
+  consume(state, [...sourcePath, "keyId"]);
+  consume(state, [...sourcePath, "password"]);
+  consume(state, [...sourcePath, "secretKey"]);
+  return { keyId, password, secretKey };
+}
 function mapReviewers(value, sourcePath, state) {
   if (Array.isArray(value)) {
     const teams2 = reviewerNames(value, "team", sourcePath, state);
@@ -763,11 +810,13 @@ function mapPublication(value, language, sourcePath, state, index) {
   const registry = publicationRegistry(type, language, [...sourcePath, "type"], index);
   const registryUrl = stringValue(nested.registryUrl);
   if (registryUrl) consume(state, [...nestedPath, "registryUrl"]);
+  const credentials = mapInlineCredentials(nested, nestedPath, state);
   if (registry === "maven") {
     const coordinate = stringValue(nested.coordinate);
+    const signature = mapMavenSignature(nested.signature, [...nestedPath, "signature"], state);
     if (coordinate) consume(state, [...nestedPath, "coordinate"]);
     return {
-      publish: compact({ registry, url: registryUrl }),
+      publish: compact({ registry, url: registryUrl, credentials, signature }),
       ...coordinate ? { package: mavenPackage(coordinate, [...nestedPath, "coordinate"], index) } : {}
     };
   }
@@ -776,7 +825,7 @@ function mapPublication(value, language, sourcePath, state, index) {
   if (packageName) consume(state, [...nestedPath, packageNameField]);
   const metadata = registry === "pypi" ? mapPypiMetadata(nested.pypiMetadata, nestedPath, state) : {};
   return {
-    publish: compact({ registry, url: registryUrl }),
+    publish: compact({ registry, url: registryUrl, credentials }),
     ...packageName || Object.keys(metadata).length ? { package: { ...optional("packageName", packageName), ...metadata } } : {}
   };
 }
@@ -868,7 +917,8 @@ function mapAuthors(value, sourcePath, state) {
     if (!isObject(author)) return [];
     const name = stringValue(author.name);
     const email = stringValue(author.email);
-    return name ? [{ name, ...optional("email", email) }] : [];
+    const url = stringValue(author.url);
+    return name ? [{ name, ...optional("email", email), ...optional("url", url) }] : [];
   });
   if (authors.length !== value.length) return void 0;
   value.forEach((author, index) => {
@@ -876,6 +926,9 @@ function mapAuthors(value, sourcePath, state) {
     if (isObject(author) && stringValue(author.email)) {
       consume(state, [...sourcePath, index, "email"]);
     }
+    if (isObject(author) && stringValue(author.url)) {
+      consume(state, [...sourcePath, index, "url"]);
+    }
   });
   return authors;
 }
@@ -893,7 +946,11 @@ function finishOutputMapping(mapping, outputMode, sourcePath, state, index) {
           code: "FERN_OUTPUT_CREDENTIAL_UNSUPPORTED",
           severity: "warning",
           path: sourcePath,
-          reason: "Fern output credentials and signatures are intentionally excluded from SDK Config v1",
+          // This diagnostic only captures credential/signature fields that remained
+          // unconsumed after mapping supported registry/GitHub credentials into
+          // SDK Config v1. Supported credential shapes are carried through; this
+          // warning is about the remaining legacy-only credential fields.
+          reason: "Some Fern output credentials and signatures are intentionally excluded from SDK Config v1 when they cannot be represented in the public schema",
           suggestedAction: "Provide publishing credentials through the build request or external secret resolution."
         }
       ] : [],
@@ -1113,15 +1170,33 @@ var sdkConfigV1PublishRegistrySchema = z.enum([
   "go",
   "composer"
 ]);
+var registryCredentialsSchema = z.strictObject({
+  username: nonEmptyStringSchema.optional(),
+  password: nonEmptyStringSchema.optional(),
+  token: nonEmptyStringSchema.optional(),
+  apiKey: nonEmptyStringSchema.optional()
+});
+var mavenSignatureSchema = z.strictObject({
+  keyId: nonEmptyStringSchema,
+  password: nonEmptyStringSchema,
+  secretKey: nonEmptyStringSchema
+});
 var commonPublishShape = {
   url: nonEmptyStringSchema.optional(),
+  /** Raw registry credentials. These values can be sensitive and must be handled as secrets. */
+  credentials: registryCredentialsSchema.optional(),
   releaseBranch: nonEmptyStringSchema.optional(),
   tolerateRepublish: z.boolean().optional()
 };
 var sdkConfigV1PublishConfigSchema = z.discriminatedUnion("registry", [
   z.strictObject({ registry: z.literal("npm"), ...commonPublishShape }),
   z.strictObject({ registry: z.literal("pypi"), ...commonPublishShape }),
-  z.strictObject({ registry: z.literal("maven"), ...commonPublishShape }),
+  z.strictObject({
+    registry: z.literal("maven"),
+    /** Raw Maven signing material. These values can be sensitive and must be handled as secrets. */
+    signature: mavenSignatureSchema.optional(),
+    ...commonPublishShape
+  }),
   z.strictObject({ registry: z.literal("nuget"), ...commonPublishShape }),
   z.strictObject({ registry: z.literal("rubygems"), ...commonPublishShape }),
   z.strictObject({ registry: z.literal("crates"), ...commonPublishShape }),
@@ -1132,12 +1207,15 @@ var reviewersSchema = z.strictObject({
   teams: z.array(nonEmptyStringSchema).optional(),
   users: z.array(nonEmptyStringSchema).optional()
 });
+var githubCredentialsSchema = registryCredentialsSchema;
 var githubOutputSchema = z.strictObject({
   repository: nonEmptyStringSchema,
   host: nonEmptyStringSchema.optional(),
   branch: nonEmptyStringSchema.optional(),
-  mode: z.enum(["release", "pull-request", "push"]).optional(),
+  mode: z.enum(["release", "pull-request", "push", "commit", "commit-and-release"]).optional(),
   reviewers: reviewersSchema.optional(),
+  /** Raw GitHub credentials. These values can be sensitive and must be handled as secrets. */
+  credentials: githubCredentialsSchema.optional(),
   privateRepository: z.boolean().optional()
 });
 var filesOutputSchema = z.strictObject({
@@ -1334,13 +1412,18 @@ var pydanticConfigSchema = z.strictObject({
   unionNaming: z.enum(["v0", "v1"]).optional(),
   useFieldAliases: z.boolean().optional()
 });
+var additionalInitExportSchema = z.strictObject({
+  from: nonEmptyStringSchema,
+  imports: z.array(nonEmptyStringSchema).min(1)
+});
 var pythonGenerationConfigSchema = z.strictObject({
   pythonVersion: nonEmptyStringSchema.optional(),
   pydanticVersion: nonEmptyStringSchema.optional(),
   pydantic: pydanticConfigSchema.optional(),
   client: pythonClientSchema.optional(),
   alwaysInitializeOptionals: z.boolean().optional(),
-  useTypedDictRequests: z.boolean().optional()
+  useTypedDictRequests: z.boolean().optional(),
+  additionalInitExports: z.array(additionalInitExportSchema).optional()
 });
 var rubyGenerationConfigSchema = z.strictObject({
   requirePaths: z.array(nonEmptyStringSchema).optional()
@@ -1613,9 +1696,14 @@ function mapFernConfigToSdkConfigV1(input) {
       "Select a Fern generator group containing at least one SDK generator."
     );
   }
+  const languages = input.group.generators.map(
+    (generator, index) => resolveLanguage(generator, index)
+  );
+  requireUniqueLanguages(languages);
+  const activeLanguages = new Set(languages);
   const mapped = input.group.generators.map((generator, index) => {
-    const language = resolveLanguage(generator, index);
-    const invocation = mapInvocation(generator, language, index);
+    const language = languages[index];
+    const invocation = mapInvocation(generator, language, activeLanguages, index);
     const outputMapping = generator.output ? { output: generator.output, unsupportedFields: [] } : mapOutput(generator, language, index);
     return {
       generator,
@@ -1624,7 +1712,6 @@ function mapFernConfigToSdkConfigV1(input) {
       ...outputMapping
     };
   });
-  requireUniqueLanguages(mapped.map(({ language }) => language));
   const clients = partitionSharedBlock(mapped.map(({ invocation }) => invocation.client));
   const docs = partitionSharedBlock(mapped.map(({ invocation }) => invocation.docs));
   const generations = partitionSharedBlock(mapped.map(({ invocation }) => invocation.generation));
@@ -1795,14 +1882,17 @@ function partitionObjectValues(values) {
   }
   return { shared, overrides };
 }
-function mapInvocation(generator, language, index) {
+function mapInvocation(generator, language, activeLanguages, index) {
   const prefix = ["group", "generators", index];
   const state = { consumedPaths: /* @__PURE__ */ new Set() };
   const config = isObject(generator.config) ? generator.config : {};
   const client = {};
   const generation = {};
   const packageConfig = {};
-  mapCommonConfig(config, state, client, generation, packageConfig, [...prefix, "config"]);
+  mapCommonConfig(language, config, state, client, generation, packageConfig, [
+    ...prefix,
+    "config"
+  ]);
   const rawGenerator = isObject(generator.raw) ? generator.raw : void 0;
   const smartCasing = typeof rawGenerator?.["smart-casing"] === "boolean" ? rawGenerator["smart-casing"] : generator.smartCasing === false ? false : void 0;
   const smartCasingDigitWordBoundary = typeof rawGenerator?.["smart-casing-digit-word-boundary"] === "boolean" ? rawGenerator["smart-casing-digit-word-boundary"] : generator.smartCasingDigitWordBoundary === true ? true : void 0;
@@ -1831,7 +1921,7 @@ function mapInvocation(generator, language, index) {
       client.pathParameterStyle = inlinePathParameters ? "inline" : "wrapped";
     }
   }
-  const docs = mapReadme(generator.readme, state, [...prefix, "readme"]);
+  const docs = mapReadme(generator.readme, language, activeLanguages, state, [...prefix, "readme"]);
   const unsupportedFields = [
     ...collectUnsupported(config, [...prefix, "config"], state),
     ...settings ? collectUnsupported(settings, [...prefix, "settings"], state) : [],
@@ -1887,7 +1977,7 @@ function resolvedFieldGuidance(field) {
 function isDefaultAutomation(value) {
   return isObject(value) && value.generate === true && value.upgrade === true && value.preview === true && value.verify === true;
 }
-function mapCommonConfig(config, state, client, generation, packageConfig, basePath) {
+function mapCommonConfig(language, config, state, client, generation, packageConfig, basePath) {
   const inlinePath = takeBoolean(config, ["inlinePathParameters"], state, basePath);
   const inlineFile = takeBoolean(config, ["inlineFileProperties"], state, basePath);
   const inlineRequest = takeBoolean(config, ["inlineRequestParams"], state, basePath);
@@ -1897,12 +1987,15 @@ function mapCommonConfig(config, state, client, generation, packageConfig, baseP
     client.requestParameterStyle = inlineRequest ? "inline" : "wrapped";
   const timeoutMs = takeTimeoutMs(config, state, basePath);
   if (timeoutMs !== void 0) client.timeoutMs = timeoutMs;
-  const skipValidation = takeBoolean(
+  const directSkipValidation = takeBoolean(
     config,
     ["skipResponseValidation", "skipValidation"],
     state,
     basePath
   );
+  const pydanticConfig = language === "python" ? takeObject(config, ["pydanticConfig"], state, basePath) : void 0;
+  const nestedSkipValidation = pydanticConfig ? takeBoolean(pydanticConfig.value, ["skipValidation"], state, pydanticConfig.path) : void 0;
+  const skipValidation = directSkipValidation ?? nestedSkipValidation;
   if (skipValidation !== void 0) client.responseValidation = !skipValidation;
   const useDefaults = takeBoolean(config, ["useDefaultRequestParameterValues"], state, basePath);
   if (useDefaults !== void 0) client.useDefaultRequestParameterValues = useDefaults;
@@ -2003,16 +2096,16 @@ function mapLanguageConfig(language, config, state, packageConfig, basePath) {
   }
 }
 function mapTypescript(config, state, packageConfig, basePath) {
-  const packageJson = takeObject(config, ["packageJson"], state, basePath);
-  const packageName = packageJson ? takeString(packageJson.value, ["name"], state, packageJson.path) : void 0;
-  if (packageName !== void 0) packageConfig.packageName = packageName;
+  mapPackageManifest(config, ["packageJson"], state, packageConfig, basePath);
   const serdeLayer = takeBoolean(config, ["serdeLayer"], state, basePath);
   const noSerdeLayer = takeBoolean(config, ["noSerdeLayer"], state, basePath);
+  const fetchSupport = takeEnum(config, ["fetchSupport"], ["native"], state, basePath);
   return compact({
     typescriptVersion: takeString(config, ["typescriptVersion"], state, basePath),
     zodVersion: takeString(config, ["zodVersion"], state, basePath),
     packageManager: takeEnum(config, ["packageManager"], ["pnpm", "yarn"], state, basePath),
     testFramework: takeEnum(config, ["testFramework"], ["jest", "vitest"], state, basePath),
+    httpClient: fetchSupport === "native" ? { name: "fetch" } : void 0,
     bundle: takeBoolean(config, ["bundle"], state, basePath),
     exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
     namespaceExportName: takeString(
@@ -2037,7 +2130,8 @@ function mapPython(config, state, packageConfig, basePath) {
     pythonVersion: takeString(config, ["pythonVersion", "pyprojectPythonVersion"], state, basePath),
     pydanticVersion: takeString(config, ["pydanticVersion"], state, basePath),
     alwaysInitializeOptionals: takeBoolean(config, ["alwaysInitializeOptionals"], state, basePath),
-    useTypedDictRequests: takeBoolean(config, ["useTypedDictRequests"], state, basePath)
+    useTypedDictRequests: takeBoolean(config, ["useTypedDictRequests"], state, basePath),
+    additionalInitExports: takePythonAdditionalInitExports(config, state, basePath)
   });
 }
 function mapJvm(language, config, state, packageConfig, basePath) {
@@ -2117,6 +2211,7 @@ function mapCsharp(config, state, packageConfig, basePath) {
   });
 }
 function mapPhp(config, state, packageConfig, basePath) {
+  mapPackageManifest(config, ["composerJson"], state, packageConfig, basePath);
   const packageName = takeString(config, ["packageName"], state, basePath);
   if (packageName !== void 0) packageConfig.packageName = packageName;
   return compact({
@@ -2199,7 +2294,7 @@ function mapMcp(config, state, basePath) {
     toolsets: takeToolsets(config, ["toolsets"], state, basePath)
   });
 }
-function mapReadme(value, state, basePath) {
+function mapReadme(value, language, activeLanguages, state, basePath) {
   if (!isObject(value)) return {};
   const readme = compact({
     apiName: takeString(value, ["apiName"], state, basePath),
@@ -2207,7 +2302,7 @@ function mapReadme(value, state, basePath) {
     apiReferenceLink: takeString(value, ["apiReferenceLink"], state, basePath),
     bannerLink: takeString(value, ["bannerLink"], state, basePath),
     disabledSections: takeStringArray(value, ["disabledSections"], state, basePath),
-    customSections: takeCustomSections(value, state, basePath),
+    customSections: takeCustomSections(value, language, activeLanguages, state, basePath),
     defaultEndpoint: takeReadmeEndpoint(value, ["defaultEndpoint"], state, basePath),
     features: takeReadmeFeatures(value, state, basePath)
   });
@@ -2269,15 +2364,59 @@ function mapDependency(name, value, state, path) {
     }
   ];
 }
-function takeCustomSections(value, state, basePath) {
+function takeCustomSections(value, language, activeLanguages, state, basePath) {
   const located = locate(value, ["customSections"], basePath);
   if (!located || !Array.isArray(located.value)) return void 0;
-  const sections = located.value.flatMap(
-    (section) => isObject(section) && section.language === void 0 && typeof section.title === "string" && typeof section.content === "string" ? [{ title: section.title, content: section.content }] : []
+  const sections = located.value.flatMap((section, index) => {
+    if (!isObject(section) || typeof section.title !== "string" || section.title.length === 0 || typeof section.content !== "string") {
+      return [];
+    }
+    const sectionLanguage = section.language;
+    if (sectionLanguage !== void 0 && (typeof sectionLanguage !== "string" || !isFernLanguage(sectionLanguage) || !activeLanguages.has(sectionLanguage))) {
+      return [];
+    }
+    consume(state, [...located.path, index]);
+    return sectionLanguage === void 0 || sectionLanguage === language ? [{ title: section.title, content: section.content }] : [];
+  });
+  return sections.length > 0 ? sections : void 0;
+}
+function mapPackageManifest(config, aliases, state, packageConfig, basePath) {
+  const manifest = takeObject(config, aliases, state, basePath);
+  if (!manifest) return;
+  const packageName = takeString(manifest.value, ["name"], state, manifest.path);
+  const description = takeString(manifest.value, ["description"], state, manifest.path);
+  const license = takeString(manifest.value, ["license"], state, manifest.path);
+  const author = takeObject(manifest.value, ["author"], state, manifest.path);
+  const authorName = author ? takeString(author.value, ["name"], state, author.path) : void 0;
+  const authors = authorName && author ? [
+    compact({
+      name: authorName,
+      email: takeString(author.value, ["email"], state, author.path),
+      url: takeString(author.value, ["url"], state, author.path)
+    })
+  ] : void 0;
+  Object.assign(
+    packageConfig,
+    compact({
+      packageName,
+      description,
+      authors,
+      license: license ? { type: license } : void 0
+    })
   );
-  if (sections.length !== located.value.length) return void 0;
+}
+function takePythonAdditionalInitExports(config, state, basePath) {
+  const located = locate(config, ["additionalInitExports"], basePath);
+  if (!located || !Array.isArray(located.value)) return void 0;
+  const exports = located.value.flatMap((entry) => {
+    if (!isObject(entry)) return [];
+    const from = stringValue(entry.from);
+    const imports = stringArrayValue(entry.imports);
+    return from && imports?.length ? [{ from, imports }] : [];
+  });
+  if (exports.length !== located.value.length) return void 0;
   consume(state, located.path);
-  return sections;
+  return exports;
 }
 function takeReadmeEndpoint(value, aliases, state, basePath) {
   const located = locate(value, aliases, basePath);