@postman/sdk-config 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -790,6 +790,7 @@ function githubOutput(value, publishInfo, rawOutput, language, sourcePath, state
   consume(state, [...sourcePath, "repo"]);
   const publication = publishInfo ? mapPublication(publishInfo, rawOutput, language, [...sourcePath, "publishInfo"], state, index) : void 0;
   const type = stringValue(value.type);
+  const licensePackage = mapGithubLicense(value.license, [...sourcePath, "license"], state);
   const reviewers = mapReviewers(value.reviewers, [...sourcePath, "reviewers"], state);
   if (type) consume(state, [...sourcePath, "type"]);
   if (typeof value.makePr === "boolean") consume(state, [...sourcePath, "makePr"]);
@@ -816,9 +817,20 @@ function githubOutput(value, publishInfo, rawOutput, language, sourcePath, state
       },
       ...publication ? { publish: publication.publish } : {}
     },
-    ...optional("package", publication?.package)
+    // The GitHub license wins over a publication-supplied one; `licensePackage` is `{}` or `{ license }`.
+    ...optionalObject("package", { ...publication?.package, ...licensePackage })
   };
 }
+var basicLicenseTypes = { mit: "MIT", apache: "APACHE" };
+function mapGithubLicense(value, sourcePath, state) {
+  if (!isObject(value) || stringValue(value.type) !== "basic") return {};
+  const id = stringValue(value.id);
+  const type = id ? basicLicenseTypes[id.toLowerCase()] : void 0;
+  if (!type) return {};
+  consume(state, [...sourcePath, "type"]);
+  consume(state, [...sourcePath, "id"]);
+  return { license: { type } };
+}
 function consumeCredentialObject(value, sourcePath, state) {
   if (!isObject(value)) return;
   for (const field of ["username", "password", "token", "apiKey"]) {
@@ -1818,17 +1830,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()
 });
 
@@ -2502,15 +2519,23 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     };
   }
   const pythonClient = language === "python" ? takeObject(config, ["client"], state, basePath) : void 0;
+  const typescriptNaming = language === "typescript" || language === "mcp" ? takeObject(config, ["naming"], state, basePath) : void 0;
   const directClientName = takeString(config, ["clientName", "clientClassName"], state, basePath);
-  const nestedClientName = pythonClient ? takeString(pythonClient.value, ["className"], state, pythonClient.path) : void 0;
+  const nestedClientName = pythonClient ? takeString(pythonClient.value, ["className"], state, pythonClient.path) : typescriptNaming ? takeString(typescriptNaming.value, ["client"], state, typescriptNaming.path) : void 0;
   const directExportedClientName = takeString(
     config,
     ["exportedClientName", "exportedClientClassName"],
     state,
     basePath
   );
-  const nestedExportedClientName = pythonClient ? takeString(pythonClient.value, ["exportedClassName"], state, pythonClient.path) : void 0;
+  const nestedExportedClientName = pythonClient ? takeString(pythonClient.value, ["exportedClassName"], state, pythonClient.path) : typescriptNaming ? (
+    // TypeScript's `naming.namespace` is the base every other naming.* field defaults from
+    // (Fern's docs: `client` defaults to `${PascalCase(namespace)}Client`, same for
+    // `environment`/`error`/etc.) — the same role `exportedClientName` already plays for every
+    // other language's `clientPrefix` derivation.
+    takeString(typescriptNaming.value, ["namespace"], state, typescriptNaming.path)
+  ) : void 0;
+  const nestedEnvironmentTypeName = typescriptNaming ? takeString(typescriptNaming.value, ["environment"], state, typescriptNaming.path) : void 0;
   const naming = compact({
     pagerName: takeString(
       config,
@@ -2520,12 +2545,7 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     ),
     clientName: directClientName ?? nestedClientName,
     exportedClientName: directExportedClientName ?? nestedExportedClientName,
-    environmentTypeName: takeString(
-      config,
-      ["environmentClassName", "environmentEnumName"],
-      state,
-      basePath
-    ),
+    environmentTypeName: takeString(config, ["environmentClassName", "environmentEnumName"], state, basePath) ?? nestedEnvironmentTypeName,
     apiErrorName: takeString(config, ["baseApiExceptionClassName"], state, basePath),
     baseErrorName: takeString(config, ["baseExceptionClassName"], state, basePath)
   });
@@ -2539,6 +2559,10 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
     basePath
   );
   if (webSockets !== void 0) generation.webSockets = webSockets;
+  if (language === "typescript") {
+    const streams = mapTypescriptStreams(config, state, basePath);
+    if (streams) generation.streams = streams;
+  }
   const generateFullProject = takeBoolean(config, ["generateFullProject"], state, basePath);
   if (generateFullProject !== void 0) generation.generateFullProject = generateFullProject;
   const inlineTypes = takeBoolean(config, ["enableInlineTypes"], state, basePath);
@@ -2556,6 +2580,18 @@ function mapCommonConfig(language, config, state, client, generation, packageCon
   if (packagePath !== void 0) generation.layout = { packagePath };
   mapDependencies(config, state, packageConfig, basePath);
 }
+function mapTypescriptStreams(config, state, basePath) {
+  const responseType = takeEnum(config, ["streamType"], ["wrapper", "web"], state, basePath);
+  const fileResponseType = takeEnum(
+    config,
+    ["fileResponseType"],
+    ["stream", "binary-response"],
+    state,
+    basePath
+  );
+  if (responseType === void 0 && fileResponseType === void 0) return void 0;
+  return { enabled: true, ...compact({ responseType, fileResponseType }) };
+}
 function mapLanguageConfig(language, config, state, packageConfig, basePath) {
   switch (language) {
     case "typescript":
@@ -2589,29 +2625,39 @@ function mapLanguageConfig(language, config, state, packageConfig, basePath) {
   }
 }
 function mapTypescript(config, state, packageConfig, basePath) {
-  mapPackageManifest(config, ["packageJson"], state, packageConfig, basePath);
+  const packageJsonManifest = mapPackageManifest(
+    config,
+    ["packageJson"],
+    state,
+    packageConfig,
+    basePath
+  );
+  const packageJsonPackageManager = packageJsonManifest ? takeString(packageJsonManifest.value, ["packageManager"], state, packageJsonManifest.path) : void 0;
+  const packageManagerAtIndex = packageJsonPackageManager ? packageJsonPackageManager.indexOf("@", packageJsonPackageManager.startsWith("@") ? 1 : 0) : -1;
+  const packageManagerVersionPart = packageManagerAtIndex >= 0 ? packageJsonPackageManager?.slice(packageManagerAtIndex + 1).split("+")[0] : void 0;
+  const packageManagerVersion = packageManagerVersionPart || void 0;
   const serdeLayer = takeBoolean(config, ["serdeLayer"], state, basePath);
   const noSerdeLayer = takeBoolean(config, ["noSerdeLayer"], state, basePath);
   const fetchSupport = takeEnum(config, ["fetchSupport"], ["native"], state, basePath);
+  const namingObject = takeObject(config, ["naming"], state, basePath);
+  const nestedNamespace = namingObject ? takeString(namingObject.value, ["namespace"], state, namingObject.path) : void 0;
   return compact({
     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,
     bundle: takeBoolean(config, ["bundle"], state, basePath),
     exportClassDefault: takeBoolean(config, ["exportClassDefault"], state, basePath),
-    namespaceExportName: takeString(
-      config,
-      ["namespaceExportName", "namespaceExport"],
-      state,
-      basePath
-    ),
+    namespaceExportName: takeString(config, ["namespaceExportName", "namespaceExport"], state, basePath) ?? nestedNamespace,
+    consolidateTypeFiles: takeBoolean(config, ["consolidateTypeFiles"], state, basePath),
     allowCustomFetcher: takeBoolean(config, ["allowCustomFetcher"], state, basePath),
     useBrandedStringAliases: takeBoolean(config, ["useBrandedStringAliases"], state, basePath),
     useLegacyExports: takeBoolean(config, ["useLegacyExports"], state, basePath),
     useBigInt: takeBoolean(config, ["useBigInt"], state, basePath),
-    serdeLayer: serdeLayer ?? (noSerdeLayer === void 0 ? void 0 : !noSerdeLayer)
+    serdeLayer: serdeLayer ?? (noSerdeLayer === void 0 ? void 0 : !noSerdeLayer),
+    esmOnly: takeBoolean(config, ["esmOnly"], state, basePath)
   });
 }
 function mapPython(config, state, packageConfig, basePath) {
@@ -2722,7 +2768,8 @@ function mapCsharp(config, state, packageConfig, basePath) {
   });
 }
 function mapPhp(config, state, packageConfig, basePath) {
-  mapPackageManifest(config, ["composerJson"], state, packageConfig, basePath);
+  const manifest = mapPackageManifest(config, ["composerJson"], state, packageConfig, basePath);
+  if (manifest) mapComposerRequirements(manifest, state, packageConfig);
   const packageName = takeString(config, ["packageName"], state, basePath);
   if (packageName !== void 0) packageConfig.packageName = packageName;
   return compact({
@@ -2730,6 +2777,20 @@ function mapPhp(config, state, packageConfig, basePath) {
     generateClientInterfaces: takeBoolean(config, ["generateClientInterfaces"], state, basePath)
   });
 }
+function mapComposerRequirements(manifest, state, packageConfig) {
+  const fields = [
+    ["require", "extraDependencies"],
+    ["require-dev", "extraDevDependencies"]
+  ];
+  for (const [composerField, packageField] of fields) {
+    const located = takeObject(manifest.value, [composerField], state, manifest.path);
+    if (!located) continue;
+    const dependencies = Object.entries(located.value).flatMap(
+      ([name, dependency]) => mapDependency(name, dependency, state, [...located.path, name])
+    );
+    if (dependencies.length) packageConfig[packageField] = dependencies;
+  }
+}
 function mapRuby(config, state, packageConfig, basePath) {
   const moduleName = takeString(config, ["moduleName"], state, basePath);
   if (moduleName !== void 0) packageConfig.moduleName = moduleName;
@@ -2899,28 +2960,52 @@ function takeCustomSections(value, language, activeLanguages, state, basePath) {
 }
 function mapPackageManifest(config, aliases, state, packageConfig, basePath) {
   const manifest = takeObject(config, aliases, state, basePath);
-  if (!manifest) return;
+  if (!manifest) return void 0;
   const packageName = takeString(manifest.value, ["name"], state, manifest.path);
   const description = takeString(manifest.value, ["description"], state, manifest.path);
+  const keywords = takeStringArray(manifest.value, ["keywords"], 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;
+  const authors = [
+    ...authorName && author ? [
+      compact({
+        name: authorName,
+        email: takeString(author.value, ["email"], state, author.path),
+        url: takeString(author.value, ["url"], state, author.path)
+      })
+    ] : [],
+    ...takeManifestAuthors(manifest, state)
+  ];
   Object.assign(
     packageConfig,
     compact({
       packageName,
       description,
-      authors,
+      homepage: takeString(manifest.value, ["homepage"], state, manifest.path),
+      keywords,
+      authors: authors.length ? authors : void 0,
       license: license ? { type: license } : void 0
     })
   );
+  return manifest;
+}
+function takeManifestAuthors(manifest, state) {
+  const located = locate(manifest.value, ["authors"], manifest.path);
+  if (!located || !Array.isArray(located.value)) return [];
+  return located.value.flatMap((entry, index) => {
+    if (!isObject(entry)) return [];
+    const path = [...located.path, index];
+    const name = takeString(entry, ["name"], state, path);
+    if (!name) return [];
+    return [
+      compact({
+        name,
+        email: takeString(entry, ["email"], state, path),
+        url: takeString(entry, ["url"], state, path)
+      })
+    ];
+  });
 }
 function takePythonAdditionalInitExports(config, state, basePath) {
   const located = locate(config, ["additionalInitExports"], basePath);