@workos/oagen 0.22.6 → 0.23.0

package/dist/{diff-CQzcGuFJ.mjs → diff-B7dMUCoJ.mjs}

@@ -715,12 +715,12 @@ function extractKotlinClassMembers(classBody, source) {
 }
 /**
 * KDoc signature that identifies a generator-emitted service accessor inside
-* the WorkOS class. The Kotlin client emitter writes every accessor with this
+* a Kotlin client class. The Kotlin client emitter writes every accessor with this
 * exact doc preamble — when the existing file carries a member with this doc
 * but the regenerated content omits it, the member is stale (its mount target
 * was remapped or removed) and gets pruned.
 */
-const KOTLIN_MANAGED_ACCESSOR_DOC = /\/\*\*[\s\S]*?Lazily-constructed \[[^\]]+\] accessor for this \[WorkOS\] client\.[\s\S]*?\*\//;
+const KOTLIN_MANAGED_ACCESSOR_DOC = /\/\*\*[\s\S]*?Lazily-constructed \[[^\]]+\] accessor for this \[[^\]]+\] client\.[\s\S]*?\*\//;
 const kotlinMergeAdapter = {
 	language: "kotlin",
 	grammarModule: "tree-sitter-kotlin",
@@ -973,7 +973,6 @@ const nodeMergeAdapter = {
 		const newText = newMembers.map((m) => m.text).join("\n");
 		for (const match of newText.matchAll(/this\.(\w+)/g)) {
 			const propName = match[1];
-			if (propName === "workos") continue;
 			if (propName && !existingMemberKeys.has(propName)) return true;
 		}
 		return false;
@@ -2667,6 +2666,60 @@ function collectTsImports(lines) {
 	return out;
 }
 /**
+* Remove the given symbols from generated `import type` bindings, in place.
+*
+* Called when an existing *value* import for the same symbol is being spliced
+* back into the file. A value import satisfies both runtime and type uses, so
+* leaving the generated `import type { X }` would re-declare `X` (TS2300
+* duplicate identifier). Callers guarantee every symbol here is absent from
+* generated *value* imports, so each occurrence is type-only and safe to drop.
+*
+* Handles whole-line `import type { … }` and inline `import { …, type X }`,
+* single- or multi-line. A statement whose bindings all get stripped is
+* removed entirely.
+*/
+function dropGeneratedTypeOnlyBindings(resultLines, symbols) {
+	if (symbols.size === 0) return;
+	const out = [];
+	for (let i = 0; i < resultLines.length; i++) {
+		const line = resultLines[i];
+		const trimmed = line.trim();
+		if (!/^import\b/.test(trimmed) || !trimmed.includes("{")) {
+			out.push(line);
+			continue;
+		}
+		const span = [line];
+		while (!span.join(" ").includes("}") && i + 1 < resultLines.length) {
+			i++;
+			span.push(resultLines[i]);
+		}
+		const m = span.join(" ").replace(/\s+/g, " ").trim().replace(/;\s*$/, "").match(/^import\s+(type\s+)?(?:(\w+)\s*,\s*)?\{\s*([^}]*)\s*\}\s+from\s+(['"][^'"]+['"])$/);
+		if (!m) {
+			for (const s of span) out.push(s);
+			continue;
+		}
+		const isTypeOnly = !!m[1];
+		const defaultName = m[2];
+		const items = m[3].split(",").map((s) => s.trim()).filter(Boolean);
+		const modQuoted = m[4];
+		const kept = items.filter((raw) => {
+			const isTypeBinding = isTypeOnly || raw.startsWith("type ");
+			const bare = raw.replace(/^type\s+/, "");
+			return !(isTypeBinding && symbols.has(bare));
+		});
+		if (kept.length === items.length) {
+			for (const s of span) out.push(s);
+			continue;
+		}
+		if (kept.length === 0 && !defaultName) continue;
+		const lead = line.match(/^(\s*)/)?.[1] ?? "";
+		const prefix = isTypeOnly ? "import type " : "import ";
+		const defaultPart = defaultName ? `${defaultName}, ` : "";
+		out.push(`${lead}${prefix}${defaultPart}{ ${kept.join(", ")} } from ${modQuoted};`);
+	}
+	resultLines.splice(0, resultLines.length, ...out);
+}
+/**
 * Add imports from the existing file that are absent from the generated
 * result. Handles:
 *
@@ -2788,28 +2841,49 @@ function spliceExtraImports(existingLines, resultLines) {
 	const existingTs = collectTsImports(existingOutsideIgnore);
 	const generatedTs = collectTsImports(resultLines);
 	const extraTsLines = [];
+	const allGeneratedTsIds = /* @__PURE__ */ new Set();
+	const generatedValueIds = /* @__PURE__ */ new Set();
+	for (const ids of generatedTs.named.values()) for (const id of ids) {
+		allGeneratedTsIds.add(id);
+		generatedValueIds.add(id);
+	}
+	for (const ids of generatedTs.typeOnly.values()) for (const id of ids) allGeneratedTsIds.add(id);
+	for (const name of generatedTs.defaults.values()) {
+		allGeneratedTsIds.add(name);
+		generatedValueIds.add(name);
+	}
+	for (const name of generatedTs.namespaces.values()) {
+		allGeneratedTsIds.add(name);
+		generatedValueIds.add(name);
+	}
+	const reclaimedValueIds = /* @__PURE__ */ new Set();
+	const generatedHasValue = (id) => generatedValueIds.has(id);
+	const generatedHasTypeOnly = (id) => allGeneratedTsIds.has(id) && !generatedValueIds.has(id);
 	for (const mod of existingTs.sideEffects) if (!generatedTs.sideEffects.has(mod)) extraTsLines.push(`import '${mod}';`);
 	for (const [mod, name] of existingTs.defaults) {
 		if (generatedTs.defaults.has(mod)) continue;
 		if (!identifierUsed(ignoreRegionText, name)) continue;
+		if (generatedHasValue(name)) continue;
+		if (generatedHasTypeOnly(name)) reclaimedValueIds.add(name);
 		extraTsLines.push(`import ${name} from '${mod}';`);
 	}
 	for (const [mod, name] of existingTs.namespaces) {
 		if (!identifierUsed(ignoreRegionText, name)) continue;
-		if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+		if (generatedHasValue(name)) continue;
+		if (generatedTs.namespaces.has(mod)) continue;
+		if (generatedHasTypeOnly(name)) reclaimedValueIds.add(name);
+		extraTsLines.push(`import * as ${name} from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.named) {
-		const genIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const genTypeIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id) && identifierUsed(ignoreRegionText, id));
+		const extra = [...existIds].filter((id) => !generatedHasValue(id) && identifierUsed(ignoreRegionText, id));
+		for (const id of extra) if (generatedHasTypeOnly(id)) reclaimedValueIds.add(id);
 		if (extra.length > 0) extraTsLines.push(`import { ${extra.join(", ")} } from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.typeOnly) {
-		const genIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const genNamedIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id) && identifierUsed(ignoreRegionText, id));
+		const extra = [...existIds].filter((id) => !allGeneratedTsIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import type { ${extra.join(", ")} } from '${mod}';`);
 	}
+	dropGeneratedTypeOnlyBindings(resultLines, reclaimedValueIds);
 	const isPhpUseImport = (l) => /^use\s+[\w\\]+\\[\w\\]*(\s+as\s+\w+)?\s*;?$/.test(l);
 	const existingPhpUse = new Set(existingOutsideIgnore.filter(isPhpUseImport).map((l) => l.trim()));
 	const generatedPhpUse = new Set(resultLines.filter(isPhpUseImport).map((l) => l.trim()));
@@ -2853,11 +2927,44 @@ function spliceExtraImports(existingLines, resultLines) {
 			if ((resultLines[i].match(/[)}]/g) ?? []).length > 0) break;
 		}
 	}
-	if (lastImportIdx >= 0) resultLines.splice(lastImportIdx + 1, 0, ...allExtra);
+	if (lastImportIdx >= 0) {
+		resultLines.splice(lastImportIdx + 1, 0, ...allExtra);
+		return;
+	}
+	let insertAt = 0;
+	let inBlockComment = false;
+	for (let i = 0; i < resultLines.length; i++) {
+		const t = resultLines[i].trim();
+		if (inBlockComment) {
+			insertAt = i + 1;
+			if (t.includes("*/")) inBlockComment = false;
+			continue;
+		}
+		if (t.startsWith("//")) {
+			insertAt = i + 1;
+			continue;
+		}
+		if (t.startsWith("/*")) {
+			insertAt = i + 1;
+			inBlockComment = !t.includes("*/");
+			continue;
+		}
+		break;
+	}
+	resultLines.splice(insertAt, 0, ...allExtra);
 }
 //#endregion
 //#region src/engine/generate-files.ts
 function buildEmitterContext(spec, options) {
+	const resolvedOperations = resolveOperations(spec, options.operationHints, options.mountRules);
+	let scopedModelNames;
+	let scopedEnumNames;
+	if (options.scopedServices && options.scopedServices.size > 0) {
+		const selected = options.scopedServices;
+		const reachable = collectReferencedNames(spec.services.filter((s) => resolvedOperations.some((r) => r.service.name === s.name && selected.has(r.mountOn))), spec.models, { preserveAllDiscriminated: false });
+		scopedModelNames = reachable.models;
+		scopedEnumNames = reachable.enums;
+	}
 	return {
 		namespace: toSnakeCase(options.namespace),
 		namespacePascal: options.namespace,
@@ -2865,11 +2972,14 @@ function buildEmitterContext(spec, options) {
 		outputDir: options.outputDir,
 		apiSurface: options.apiSurface,
 		overlayLookup: options.overlayLookup,
-		resolvedOperations: resolveOperations(spec, options.operationHints, options.mountRules),
+		resolvedOperations,
 		modelHints: options.modelHints,
 		emitterOptions: options.emitterOptions,
 		targetDir: options.target,
-		priorTargetManifestPaths: options.priorTargetManifestPaths
+		priorTargetManifestPaths: options.priorTargetManifestPaths,
+		scopedServices: options.scopedServices,
+		scopedModelNames,
+		scopedEnumNames
 	};
 }
 /**
@@ -2877,7 +2987,8 @@ function buildEmitterContext(spec, options) {
 * Walks operation parameters, request bodies, responses, and pagination item
 * types, then chases model field references until the set stabilizes.
 */
-function collectReferencedNames(services, models) {
+function collectReferencedNames(services, models, opts = {}) {
+	const preserveAllDiscriminated = opts.preserveAllDiscriminated !== false;
 	const referencedModels = /* @__PURE__ */ new Set();
 	const referencedEnums = /* @__PURE__ */ new Set();
 	const collectFromTypeRef = (ref) => {
@@ -2899,7 +3010,7 @@ function collectReferencedNames(services, models) {
 		for (const err of op.errors) if (err.type) collectFromTypeRef(err.type);
 		if (op.successResponses) for (const sr of op.successResponses) collectFromTypeRef(sr.type);
 	}
-	for (const model of models) {
+	if (preserveAllDiscriminated) for (const model of models) {
 		if (isDiscriminatedModel(model)) referencedModels.add(model.name);
 		const disc = model.discriminator;
 		if (disc?.mapping) for (const variantName of Object.values(disc.mapping)) referencedModels.add(variantName);
@@ -2913,6 +3024,13 @@ function collectReferencedNames(services, models) {
 		visited.add(name);
 		const model = modelsByName.get(name);
 		if (!model) continue;
+		const disc = model.discriminator;
+		if (disc?.mapping) {
+			for (const variantName of Object.values(disc.mapping)) if (!referencedModels.has(variantName)) {
+				referencedModels.add(variantName);
+				queue.push(variantName);
+			}
+		}
 		for (const field of model.fields) {
 			collectFromTypeRef(field.type);
 			for (const m of referencedModels) if (!visited.has(m)) queue.push(m);
@@ -2926,7 +3044,16 @@ function collectReferencedNames(services, models) {
 function isDiscriminatedModel(model) {
 	return model.fields.some((field) => (field.name === "event" || field.name === "type" || field.name === "object") && field.type.kind === "literal");
 }
-/** Collect all generated files from an emitter (no headers, no path prefixes). */
+/**
+* Collect all generated files from an emitter (no headers, no path prefixes).
+*
+* In a scoped (`--services`) run the spec is NOT filtered: every generator runs
+* over the full spec so model placement, dedup, the root client, and all
+* aggregate/barrel files are byte-identical to a full run (and a brand-new
+* selected service is wired into the client automatically). The emitters
+* themselves consult `ctx.scopedServices` to emit only the selected services'
+* per-service resource/test files.
+*/
 function generateAllFiles(spec, emitter, ctx) {
 	const referenced = collectReferencedNames(spec.services, spec.models);
 	const reachableModels = spec.models.filter((m) => referenced.models.has(m.name));
@@ -2967,6 +3094,47 @@ function generateFiles(spec, emitter, options) {
 	};
 }
 //#endregion
+//#region src/engine/scoped-services.ts
+/**
+* Validate a `--services` selection and return it as a set of POST-MOUNT service
+* names for emitters to scope on.
+*
+* Scoped generation does NOT filter the IR: model placement, dedup/aliasing, and
+* shared-schema decisions are global computations over the full service/model set
+* (filtering them churns shared `common/` files). Instead the full spec flows to
+* the emitters unchanged and this set is passed as `ctx.scopedServices`; each
+* emitter gates only its per-service resource/test emission on it.
+*
+* Matching is on the POST-MOUNT name. Mount resolution never mutates
+* `spec.services` — the post-mount target lives on `ResolvedOperation.mountOn`
+* (`mountOn = hint?.mountOn ?? mountRules[service.name] ?? service.name`) — so the
+* post-mount name of a source service is derived here as
+* `mountRules[service.name] ?? service.name`. Selecting a target (e.g.
+* `DirectorySync`) is valid because every source tag that mounts into it
+* (`DirectoryUsers`, `DirectoryGroups`, …) shares that post-mount name, and the
+* emitters group resources by mount, so all siblings emit together.
+*
+* @param spec - The parsed API spec (never mutated; never filtered).
+* @param selected - Post-mount service names from `--services` (normalized/trimmed).
+* @param mountRules - Source-service-name → post-mount-target mappings.
+* @returns The validated selection as a `Set` of post-mount names.
+* @throws A `ConfigError` listing valid post-mount names when a selection is
+*   unknown — scoped generation never silently emits the wrong set.
+*/
+function resolveScopedServices(spec, selected, mountRules) {
+	const mounts = mountRules ?? {};
+	const postMountName = (name) => mounts[name] ?? name;
+	const validPostMount = new Set(spec.services.map((s) => postMountName(s.name)));
+	const selectedSet = new Set(selected);
+	const unknown = [...selectedSet].filter((s) => !validPostMount.has(s));
+	if (unknown.length > 0) {
+		const err = /* @__PURE__ */ new Error(`Unknown --services: ${unknown.sort().join(", ")}. Valid post-mount services: ${[...validPostMount].sort().join(", ")}`);
+		err.name = "ConfigError";
+		throw err;
+	}
+	return selectedSet;
+}
+//#endregion
 //#region src/engine/integrate.ts
 /**
 * Resolve a relative import path against a source file path to get the
@@ -3083,7 +3251,7 @@ function mapFilesForTargetIntegration(files, language) {
 * that would shadow an existing module file (e.g., `api_keys.py`), move the
 * module file's content into `_compat.py` inside the package and add a
 * re-export from `__init__.py`.  This preserves backward-compatible imports
-* (e.g., `from workos.api_keys import ApiKeysModule`) while the package directory
+* (e.g., `from acme.api_keys import ApiKeysModule`) while the package directory
 * provides the generated models and resource classes.
 */
 async function resolveFileToDirectoryConflicts(files, targetDir) {
@@ -3249,6 +3417,35 @@ function computeStalePaths(prev, currentPaths) {
 	return prev.files.filter((p) => !current.has(p)).sort();
 }
 /**
+* Merge a scoped run's emitted records into the prior manifest's records.
+*
+* A scoped (`--services`) run only emits files for the selected services, but it
+* must NOT discard the prior manifest's record of unselected services' files
+* records. The result unions prior + scoped file paths and shallow-merges the
+* operations maps, with scoped operations overriding prior entries for the same
+* "METHOD /path" key (a re-emission updates that operation's record).
+*
+* When `prev` is null (the first-ever run is scoped) there is nothing to
+* preserve, so the scoped subset is returned unchanged — matching the
+* first-adoption behavior of a full run.
+*/
+function mergeScopedManifestRecords(prev, scopedFiles, scopedOperations) {
+	const scopedFileList = [...scopedFiles];
+	if (!prev) return {
+		files: scopedFileList,
+		operations: scopedOperations
+	};
+	const files = [...new Set([...prev.files, ...scopedFileList])].sort();
+	const priorOps = prev.operations;
+	return {
+		files,
+		operations: priorOps || scopedOperations ? {
+			...priorOps,
+			...scopedOperations
+		} : void 0
+	};
+}
+/**
 * Delete stale files from `dir`.
 *
 * When `header` is provided, a file is only deleted if its contents start with
@@ -3317,12 +3514,17 @@ async function removeEmptyParents(startDir, stopDir) {
 //#endregion
 //#region src/engine/orchestrator.ts
 async function generate(spec, emitter, options) {
-	const outputPrevManifestForCtx = options.noPrune ? null : await readManifest(options.outputDir);
-	const targetManifestForCtx = options.target && !options.noPrune ? await readManifest(options.target) : null;
+	const scopedServices = options.services && options.services.length > 0 ? resolveScopedServices(spec, options.services, options.mountRules) : void 0;
+	const scoped = scopedServices !== void 0;
+	const noPrune = options.noPrune === true || scoped;
+	const skipManifestRead = options.noPrune === true && !scoped;
+	const outputPrevManifestForCtx = skipManifestRead ? null : await readManifest(options.outputDir);
+	const targetManifestForCtx = options.target && !skipManifestRead ? await readManifest(options.target) : null;
 	const priorTargetManifestPaths = targetManifestForCtx ? new Set(targetManifestForCtx.files) : outputPrevManifestForCtx ? new Set(outputPrevManifestForCtx.files) : void 0;
 	const { files: withHeaders, header, operations } = generateFiles(spec, emitter, {
 		...options,
-		priorTargetManifestPaths
+		priorTargetManifestPaths,
+		scopedServices
 	});
 	if (options.dryRun) {
 		if (options.target) {
@@ -3346,8 +3548,9 @@ async function generate(spec, emitter, options) {
 		currentPaths: outputEmittedPaths,
 		language: emitter.language,
 		header,
-		noPrune: options.noPrune,
-		operations
+		noPrune,
+		operations,
+		scoped
 	});
 	const allOutputFiles = [...writeResult.written, ...writeResult.merged];
 	if (allOutputFiles.length > 0) await formatTargetFiles(emitter, options.outputDir, allOutputFiles);
@@ -3369,8 +3572,9 @@ async function generate(spec, emitter, options) {
 			currentPaths: targetResult.emittedPaths,
 			language: emitter.language,
 			header,
-			noPrune: options.noPrune,
-			operations
+			noPrune,
+			operations,
+			scoped
 		});
 		const allTargetFiles = [
 			...targetResult.written,
@@ -3386,11 +3590,15 @@ async function generate(spec, emitter, options) {
 * then write the fresh manifest.  Safe on first adoption (no previous manifest).
 */
 async function applyManifestPrune(opts) {
-	const manifestOpts = {
-		language: opts.language,
+	const records = opts.scoped ? mergeScopedManifestRecords(opts.prevManifest, opts.currentPaths, opts.operations) : {
 		files: opts.currentPaths,
 		operations: opts.operations
 	};
+	const manifestOpts = {
+		language: opts.language,
+		files: records.files,
+		operations: records.operations
+	};
 	if (opts.noPrune) {
 		await writeManifest(opts.dir, manifestOpts);
 		return;
@@ -3861,4 +4069,4 @@ function summarize(changes) {
 //#endregion
 export { MANIFEST_FILENAME as a, treeShakeFiles as c, collectReferencedNames as d, generateAllFiles as f, resolveOperations as h, generate as i, applyFileHeaders as l, deriveMethodName as m, getEmitter as n, integrateGeneratedFiles as o, generateFiles as p, registerEmitter as r, mapFilesForTargetIntegration as s, diffSpecs as t, buildEmitterContext as u };
 
-//# sourceMappingURL=diff-CQzcGuFJ.mjs.map
+//# sourceMappingURL=diff-B7dMUCoJ.mjs.map