@workos/oagen 0.23.0 → 0.24.1

package/dist/{diff-B7dMUCoJ.mjs → diff-8vcYeHKf.mjs}

@@ -2954,6 +2954,58 @@ function spliceExtraImports(existingLines, resultLines) {
 	resultLines.splice(insertAt, 0, ...allExtra);
 }
 //#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.
+*/
+/**
+* Canonicalize a service name to a casing/separator-insensitive key so that
+* `MultiFactorAuth` (post-mount IR name), `multi_factor_auth` (snake-cased
+* manifest record), and `multiFactorAuth` (camel-cased manifest record) all
+* collapse to `multifactorauth`. Used to match a spec service against the
+* services a prior manifest recorded as already on disk, where the casing of
+* the recorded `service` field varies per emitter.
+*/
+function canonicalServiceKey(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+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/generate-files.ts
 function buildEmitterContext(spec, options) {
 	const resolvedOperations = resolveOperations(spec, options.operationHints, options.mountRules);
@@ -2978,11 +3030,32 @@ function buildEmitterContext(spec, options) {
 		targetDir: options.target,
 		priorTargetManifestPaths: options.priorTargetManifestPaths,
 		scopedServices: options.scopedServices,
+		presentServiceKeys: options.presentServiceKeys,
 		scopedModelNames,
 		scopedEnumNames
 	};
 }
 /**
+* The services an aggregate (barrel/client/test) generator may reference in a
+* scoped run: the selected services plus every service the prior manifest
+* recorded as already on disk. A service the spec just added that is neither
+* selected nor already generated is excluded — otherwise the client/barrels
+* would import a resource/model whose file this run does not emit (the orphaned
+* `agents/__init__.py → ._resource` class of build break).
+*
+* Outside a scoped run (full generation), every service is in surface.
+*/
+function aggregateSurfaceServices(spec, ctx) {
+	const scope = ctx.scopedServices;
+	if (!scope || scope.size === 0) return spec.services;
+	const present = ctx.presentServiceKeys ?? /* @__PURE__ */ new Set();
+	const postMountOf = (service) => ctx.resolvedOperations?.find((r) => r.service.name === service.name)?.mountOn ?? service.name;
+	return spec.services.filter((s) => {
+		const postMount = postMountOf(s);
+		return scope.has(postMount) || present.has(canonicalServiceKey(postMount));
+	});
+}
+/**
 * Collect model and enum names transitively referenced by service operations.
 * Walks operation parameters, request bodies, responses, and pagination item
 * types, then chases model field references until the set stabilizes.
@@ -3047,27 +3120,38 @@ function isDiscriminatedModel(model) {
 /**
 * 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.
+* A full run emits over the whole spec. A scoped (`--services`) run still emits
+* model placement, dedup, the root client, and aggregate/barrel files
+* byte-identically for every service ALREADY on disk (plus the brand-new
+* selected service, which is wired into the client automatically) — but it
+* narrows that surface to `selected ∪ already-on-disk` services
+* (`aggregateSurfaceServices`). A service the spec just added that is neither
+* selected nor already generated is dropped from the surface entirely, so its
+* models/discriminators are not pulled into reachability and barrels/the client
+* never import a resource this run does not emit. The emitters additionally
+* 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 scoped = !!ctx.scopedServices && ctx.scopedServices.size > 0;
+	const surfaceServices = aggregateSurfaceServices(spec, ctx);
+	const referenced = collectReferencedNames(surfaceServices, spec.models, { preserveAllDiscriminated: !scoped });
 	const reachableModels = spec.models.filter((m) => referenced.models.has(m.name));
 	const reachableEnums = spec.enums.filter((e) => referenced.enums.has(e.name));
-	const reachableSpec = {
+	const surfaceSpec = {
 		...spec,
+		services: surfaceServices
+	};
+	const reachableSpec = {
+		...surfaceSpec,
 		models: reachableModels,
 		enums: reachableEnums
 	};
 	return [
 		...emitter.generateModels(reachableModels, ctx),
 		...emitter.generateEnums(reachableEnums, ctx),
-		...emitter.generateResources(spec.services, ctx),
-		...emitter.generateClient(spec, ctx),
+		...emitter.generateResources(surfaceServices, ctx),
+		...emitter.generateClient(surfaceSpec, ctx),
 		...emitter.generateErrors(ctx),
 		...emitter.generateTypeSignatures?.(reachableSpec, ctx) ?? [],
 		...emitter.generateTests(reachableSpec, ctx)
@@ -3084,7 +3168,11 @@ function applyFileHeaders(files, header) {
 function generateFiles(spec, emitter, options) {
 	const ctx = buildEmitterContext(spec, options);
 	const files = generateAllFiles(spec, emitter, ctx);
-	const operations = emitter.buildOperationsMap?.(spec, ctx);
+	const surfaceSpec = {
+		...spec,
+		services: aggregateSurfaceServices(spec, ctx)
+	};
+	const operations = emitter.buildOperationsMap?.(surfaceSpec, ctx);
 	const header = emitter.fileHeader();
 	return {
 		files: applyFileHeaders(files, header),
@@ -3094,47 +3182,6 @@ 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
@@ -3446,6 +3493,35 @@ function mergeScopedManifestRecords(prev, scopedFiles, scopedOperations) {
 	};
 }
 /**
+* Extract the set of services a prior manifest records as already generated on
+* disk, as canonical (casing/separator-insensitive) keys.
+*
+* The manifest's `operations` map carries each operation's owning `service`
+* (snake_case for most emitters, camelCase for Kotlin). A scoped (`--services`)
+* run uses this to tell "service in the spec that is already on disk" apart from
+* "service the spec just added that this SDK has never generated" — only the
+* former may be wired into aggregate/barrel/client files alongside the
+* selection, so a brand-new out-of-scope service is never referenced by files
+* whose implementation this run does not emit.
+*
+* Returns an empty set when the manifest is null or carries no operations
+* (a legacy manifest with no operations data); callers treat that as "present
+* set unknown" and fall back to not narrowing the surface.
+*/
+function manifestServiceKeys(manifest) {
+	const keys = /* @__PURE__ */ new Set();
+	const ops = manifest?.operations;
+	if (!ops) return keys;
+	for (const value of Object.values(ops)) {
+		const entries = Array.isArray(value) ? value : [value];
+		for (const entry of entries) {
+			const service = entry?.service;
+			if (typeof service === "string" && service.length > 0) keys.add(canonicalServiceKey(service));
+		}
+	}
+	return keys;
+}
+/**
 * Delete stale files from `dir`.
 *
 * When `header` is provided, a file is only deleted if its contents start with
@@ -3520,11 +3596,14 @@ async function generate(spec, emitter, options) {
 	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 priorManifestForCtx = targetManifestForCtx ?? outputPrevManifestForCtx;
+	const priorTargetManifestPaths = priorManifestForCtx ? new Set(priorManifestForCtx.files) : void 0;
+	const presentServiceKeys = scoped ? manifestServiceKeys(priorManifestForCtx) : void 0;
 	const { files: withHeaders, header, operations } = generateFiles(spec, emitter, {
 		...options,
 		priorTargetManifestPaths,
-		scopedServices
+		scopedServices,
+		presentServiceKeys
 	});
 	if (options.dryRun) {
 		if (options.target) {
@@ -4069,4 +4148,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-B7dMUCoJ.mjs.map
+//# sourceMappingURL=diff-8vcYeHKf.mjs.map