@hey-api/shared 0.1.1 → 0.2.0

package/dist/index.mjs

@@ -1782,7 +1782,7 @@ function pathToJsonPointer(path$1) {
 	return "#" + (segments ? `/${segments}` : "");
 }
 /**
-* Checks if a $ref points to a top-level component (not a deep path reference).
+* Checks if a $ref or path points to a top-level component (not a deep path reference).
 *
 * Top-level component references:
 * - OpenAPI 3.x: #/components/{type}/{name} (3 segments)
@@ -1791,11 +1791,11 @@ function pathToJsonPointer(path$1) {
 * Deep path references (4+ segments for 3.x, 3+ for 2.0) should be inlined
 * because they don't have corresponding registered symbols.
 *
-* @param $ref - The $ref string to check
+* @param refOrPath - The $ref string or path array to check
 * @returns true if the ref points to a top-level component, false otherwise
 */
-function isTopLevelComponentRef($ref) {
-	const path$1 = jsonPointerToPath($ref);
+function isTopLevelComponent(refOrPath) {
+	const path$1 = refOrPath instanceof Array ? refOrPath : jsonPointerToPath(refOrPath);
 	if (path$1[0] === "components") return path$1.length === 3;
 	if (path$1[0] === "definitions") return path$1.length === 2;
 	return false;
@@ -2038,14 +2038,14 @@ var PluginInstance = class {
 	symbol(name, symbol) {
 		const symbolIn = {
 			...symbol,
-			exportFrom: symbol?.exportFrom ?? (!symbol?.external && this.context.config.output.indexFile && this.config.exportFromIndex ? ["index"] : void 0),
-			getFilePath: symbol?.getFilePath ?? this.getSymbolFilePath.bind(this),
 			meta: {
 				pluginName: path.isAbsolute(this.name) ? "custom" : this.name,
 				...symbol?.meta
 			},
 			name
 		};
+		if (symbolIn.getExportFromFilePath === void 0) symbolIn.getExportFromFilePath = this.getSymbolExportFromFilePath.bind(this);
+		if (symbolIn.getFilePath === void 0) symbolIn.getFilePath = this.getSymbolFilePath.bind(this);
 		for (const hook of this.eventHooks["symbol:register:before"]) hook({
 			plugin: this,
 			symbol: symbolIn
@@ -2100,6 +2100,22 @@ var PluginInstance = class {
 			pluginName: this.name
 		});
 	}
+	getSymbolExportFromFilePath(symbol) {
+		const hooks = [this.config["~hooks"]?.symbols, this.context.config.parser.hooks.symbols];
+		for (const hook of hooks) {
+			const result = hook?.getExportFromFilePath?.(symbol);
+			if (result !== void 0) return result;
+		}
+		const entryFile = this.context.config.output.indexFile ?? this.context.config.output.entryFile;
+		if (symbol.external || !entryFile) return;
+		const includeInEntry = this.config.exportFromIndex ?? this.config.includeInEntry;
+		if (typeof includeInEntry === "boolean" && !includeInEntry || typeof includeInEntry === "function" && !includeInEntry(symbol)) return;
+		const language = symbol.node?.language;
+		if (!language) return;
+		const moduleEntryName = this.gen.moduleEntryNames[language];
+		if (!moduleEntryName) return;
+		return [moduleEntryName];
+	}
 	getSymbolFilePath(symbol) {
 		const hooks = [this.config["~hooks"]?.symbols, this.context.config.parser.hooks.symbols];
 		for (const hook of hooks) {
@@ -3564,6 +3580,92 @@ const removeOriginalSplitSchemas = ({ logger, originalSchemas, spec, split }) =>
 	event.timeEnd();
 };
 /**
+* Create writable variants of parent schemas that have discriminators
+* and are referenced by split schemas.
+*/
+function splitDiscriminatorSchemas({ config, existingNames, schemasPointerNamespace, spec, split }) {
+	const schemasObj = getSchemasObject(spec);
+	if (!schemasObj) return;
+	const parentSchemasToSplit = /* @__PURE__ */ new Map();
+	for (const [name, schema] of Object.entries(split.schemas)) {
+		const pointer = `${schemasPointerNamespace}${name}`;
+		const originalPointer = split.reverseMapping[pointer];
+		if (originalPointer) {
+			const mapping = split.mapping[originalPointer];
+			if (mapping) {
+				const contextVariant = mapping.read === pointer ? "read" : mapping.write === pointer ? "write" : null;
+				if (contextVariant && schema && typeof schema === "object" && "allOf" in schema && schema.allOf instanceof Array) {
+					for (const comp of schema.allOf) if (comp && typeof comp === "object" && "$ref" in comp && typeof comp.$ref === "string") {
+						const refPath = jsonPointerToPath(comp.$ref);
+						const schemaName = refPath[refPath.length - 1];
+						if (typeof schemaName === "string" && schemaName in schemasObj) {
+							const resolvedSchema = schemasObj[schemaName];
+							if (resolvedSchema && typeof resolvedSchema === "object" && "discriminator" in resolvedSchema && resolvedSchema.discriminator && typeof resolvedSchema.discriminator === "object" && "mapping" in resolvedSchema.discriminator && resolvedSchema.discriminator.mapping && typeof resolvedSchema.discriminator.mapping === "object") {
+								if (!parentSchemasToSplit.has(comp.$ref)) parentSchemasToSplit.set(comp.$ref, /* @__PURE__ */ new Set());
+								parentSchemasToSplit.get(comp.$ref).add(contextVariant);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	const parentSchemaVariants = /* @__PURE__ */ new Map();
+	for (const [parentRef, contexts] of parentSchemasToSplit) {
+		const refPath = jsonPointerToPath(parentRef);
+		const parentName = refPath[refPath.length - 1];
+		if (typeof parentName !== "string" || !(parentName in schemasObj)) continue;
+		const parentSchema = schemasObj[parentName];
+		if (!parentSchema || typeof parentSchema !== "object") continue;
+		const variants = {};
+		for (const context of contexts) {
+			const variantSchema = deepClone(parentSchema);
+			if ("discriminator" in variantSchema && variantSchema.discriminator && typeof variantSchema.discriminator === "object" && "mapping" in variantSchema.discriminator && variantSchema.discriminator.mapping && typeof variantSchema.discriminator.mapping === "object") {
+				const mapping = variantSchema.discriminator.mapping;
+				const updatedMapping = {};
+				for (const [discriminatorValue, originalRef] of Object.entries(mapping)) {
+					const map = split.mapping[originalRef];
+					if (map) if (context === "read" && map.read) updatedMapping[discriminatorValue] = map.read;
+					else if (context === "write" && map.write) updatedMapping[discriminatorValue] = map.write;
+					else updatedMapping[discriminatorValue] = originalRef;
+					else updatedMapping[discriminatorValue] = originalRef;
+				}
+				variantSchema.discriminator.mapping = updatedMapping;
+			}
+			if (context === "write") {
+				const writeName = getUniqueComponentName({
+					base: applyNaming(parentName, config.requests),
+					components: existingNames
+				});
+				existingNames.add(writeName);
+				split.schemas[writeName] = variantSchema;
+				variants.write = `${schemasPointerNamespace}${writeName}`;
+			}
+		}
+		parentSchemaVariants.set(parentRef, variants);
+	}
+	for (const [name, schema] of Object.entries(split.schemas)) {
+		const pointer = `${schemasPointerNamespace}${name}`;
+		const originalPointer = split.reverseMapping[pointer];
+		if (!originalPointer) continue;
+		const mapping = split.mapping[originalPointer];
+		if (!mapping) continue;
+		const contextVariant = mapping.read === pointer ? "read" : mapping.write === pointer ? "write" : null;
+		if (contextVariant && schema && typeof schema === "object") {
+			if ("allOf" in schema && schema.allOf instanceof Array) for (let i = 0; i < schema.allOf.length; i++) {
+				const comp = schema.allOf[i];
+				if (comp && typeof comp === "object" && "$ref" in comp && typeof comp.$ref === "string") {
+					const variants = parentSchemaVariants.get(comp.$ref);
+					if (variants) {
+						if (contextVariant === "write" && variants.write) comp.$ref = variants.write;
+						else if (contextVariant === "read" && variants.read) comp.$ref = variants.read;
+					}
+				}
+			}
+		}
+	}
+}
+/**
 * Splits schemas with both 'read' and 'write' scopes into read/write variants.
 * Returns the new schemas and a mapping from original pointer to new variant pointers.
 *
@@ -3634,6 +3736,13 @@ const splitSchemas = ({ config, graph: graph$1, logger, spec }) => {
 		split.reverseMapping[readPointer] = pointer;
 		split.reverseMapping[writePointer] = pointer;
 	}
+	splitDiscriminatorSchemas({
+		config,
+		existingNames,
+		schemasPointerNamespace,
+		spec,
+		split
+	});
 	event.timeEnd();
 	return split;
 };
@@ -3774,6 +3883,26 @@ const updateRefsInSpec = ({ logger, spec, split }) => {
 						else if (nextContext === "write" && map.write) node[key] = map.write;
 						else if (!nextContext && map.read) node[key] = map.read;
 					}
+				} else if (key === "discriminator" && typeof value === "object" && value !== null) {
+					if ("mapping" in value && value.mapping && typeof value.mapping === "object") {
+						const updatedMapping = {};
+						for (const [discriminatorValue, originalRef] of Object.entries(value.mapping)) {
+							const map = split.mapping[originalRef];
+							if (map) if (nextContext === "read" && map.read) updatedMapping[discriminatorValue] = map.read;
+							else if (nextContext === "write" && map.write) updatedMapping[discriminatorValue] = map.write;
+							else updatedMapping[discriminatorValue] = originalRef;
+							else updatedMapping[discriminatorValue] = originalRef;
+						}
+						value.mapping = updatedMapping;
+					}
+					walk$1({
+						context: nextContext,
+						currentPointer: nextPointer,
+						inSchema,
+						node: value,
+						path: [...path$1, key],
+						visited
+					});
 				} else walk$1({
 					context: nextContext,
 					currentPointer: nextPointer,
@@ -4235,7 +4364,7 @@ const parseEnum$2 = ({ context, schema, state }) => {
 };
 const parseRef$2 = ({ context, schema, state }) => {
 	const irSchema = {};
-	if (!isTopLevelComponentRef(schema.$ref)) {
+	if (!isTopLevelComponent(schema.$ref)) {
 		if (!state.circularReferenceTracker.has(schema.$ref)) {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
@@ -5561,7 +5690,7 @@ const parseOneOf$1 = ({ context, schema, state }) => {
 	return irSchema;
 };
 const parseRef$1 = ({ context, schema, state }) => {
-	if (!isTopLevelComponentRef(schema.$ref)) {
+	if (!isTopLevelComponent(schema.$ref)) {
 		if (!state.circularReferenceTracker.has(schema.$ref)) {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
@@ -6909,7 +7038,7 @@ const parseOneOf = ({ context, schema, state }) => {
 	return irSchema;
 };
 const parseRef = ({ context, schema, state }) => {
-	if (!isTopLevelComponentRef(schema.$ref)) {
+	if (!isTopLevelComponent(schema.$ref)) {
 		if (!state.circularReferenceTracker.has(schema.$ref)) {
 			const refSchema = context.resolveRef(schema.$ref);
 			const originalRef = state.$ref;
@@ -8015,6 +8144,43 @@ function patchOpenApiSpec({ patchOptions, spec: _spec }) {
 	}
 }
 
+//#endregion
+//#region src/plugins/schema-processor.ts
+function createSchemaProcessor() {
+	const emitted = /* @__PURE__ */ new Set();
+	let contextTags;
+	let contextAnchor;
+	return {
+		get context() {
+			return {
+				anchor: contextAnchor,
+				tags: contextTags
+			};
+		},
+		hasEmitted(path$1) {
+			return emitted.has(pathToJsonPointer(path$1));
+		},
+		markEmitted(path$1) {
+			const pointer = pathToJsonPointer(path$1);
+			if (emitted.has(pointer)) return false;
+			emitted.add(pointer);
+			return true;
+		},
+		withContext(ctx, fn) {
+			const prevTags = contextTags;
+			const prevAnchor = contextAnchor;
+			contextTags = ctx.tags;
+			contextAnchor = ctx.anchor;
+			try {
+				return fn();
+			} finally {
+				contextTags = prevTags;
+				contextAnchor = prevAnchor;
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/plugins/shared/utils/config.ts
 const definePluginConfig = (defaultConfig) => (userConfig) => ({
@@ -8052,5 +8218,109 @@ const utils = {
 };
 
 //#endregion
-export { ConfigError, ConfigValidationError, Context, HeyApiError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, applyNaming, buildGraph, checkNodeVersion, compileInputPath, createOperationKey, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponentRef, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
+//#region src/utils/path.ts
+/**
+* After these structural segments, the next segment has a known role.
+* This is what makes a property literally named "properties" safe —
+* it occupies the name position, never the structural position.
+*/
+const STRUCTURAL_ROLE = {
+	items: "index",
+	patternProperties: "name",
+	properties: "name"
+};
+/**
+* These structural segments have no following name/index —
+* they are the terminal structural node. Append a suffix
+* to disambiguate from the parent.
+*/
+const STRUCTURAL_SUFFIX = { additionalProperties: "Value" };
+/**
+* Root context configuration.
+*/
+const ROOT_CONTEXT = {
+	components: {
+		names: 1,
+		skip: 2
+	},
+	definitions: {
+		names: 1,
+		skip: 1
+	},
+	paths: {
+		names: 2,
+		skip: 1
+	},
+	webhooks: {
+		names: 2,
+		skip: 1
+	}
+};
+/**
+* Sanitizes a path segment for use in a derived name.
+*
+* Handles API path segments like `/api/v1/users/{id}` → `ApiV1UsersId`.
+*/
+function sanitizeSegment(segment) {
+	const str = String(segment);
+	if (str.startsWith("/")) return str.split("/").filter(Boolean).map((part) => {
+		const clean = part.replace(/[{}]/g, "");
+		return clean.charAt(0).toUpperCase() + clean.slice(1);
+	}).join("");
+	return str;
+}
+/**
+* Derives a composite name from a path.
+*
+* Examples:
+*   .../User                                    → 'User'
+*   .../User/properties/address                 → 'UserAddress'
+*   .../User/properties/properties              → 'UserProperties'
+*   .../User/properties/address/properties/city → 'UserAddressCity'
+*   .../Pet/additionalProperties                → 'PetValue'
+*   .../Order/properties/items/items/0          → 'OrderItems'
+*   paths//event/get/properties/query           → 'EventGetQuery'
+*
+* With anchor:
+*   paths//event/get/properties/query, { anchor: 'event.subscribe' }
+*                                               → 'event.subscribe-Query'
+*/
+function pathToName(path$1, options) {
+	const names = [];
+	let index = 0;
+	const rootContext = ROOT_CONTEXT[path$1[0]];
+	if (rootContext) {
+		index = rootContext.skip;
+		if (options?.anchor) {
+			names.push(options.anchor);
+			index += rootContext.names;
+		} else for (let n = 0; n < rootContext.names && index < path$1.length; n++) {
+			names.push(sanitizeSegment(path$1[index]));
+			index++;
+		}
+	} else if (options?.anchor) {
+		names.push(options.anchor);
+		index++;
+	} else if (index < path$1.length) {
+		names.push(sanitizeSegment(path$1[index]));
+		index++;
+	}
+	while (index < path$1.length) {
+		const segment = String(path$1[index]);
+		const role = STRUCTURAL_ROLE[segment];
+		if (role === "name") {
+			index++;
+			if (index < path$1.length) names.push(sanitizeSegment(path$1[index]));
+		} else if (role === "index") {
+			index++;
+			if (index < path$1.length && typeof path$1[index] === "number") index++;
+			continue;
+		} else if (STRUCTURAL_SUFFIX[segment]) names.push(STRUCTURAL_SUFFIX[segment]);
+		index++;
+	}
+	return decodeURI(names.join("-"));
+}
+
+//#endregion
+export { ConfigError, ConfigValidationError, Context, HeyApiError, IntentContext, JobError, MinHeap, OperationPath, OperationStrategy, PluginInstance, addItemsToSchema, applyNaming, buildGraph, checkNodeVersion, compileInputPath, createOperationKey, createSchemaProcessor, debugTools, deduplicateSchema, defaultPaginationKeywords, definePluginConfig, dependencyFactory, encodeJsonPointerSegment, ensureDirSync, escapeComment, findPackageJson, findTsConfigPath, getInput, getLogs, getParser, getSpec, hasOperationDataRequired, hasParameterGroupObjectRequired, hasParametersObjectRequired, heyApiRegistryBaseUrl, inputToApiRegistry, isTopLevelComponent, jsonPointerToPath, loadPackageJson, loadTsConfig, logCrashReport, logInputPaths, mappers, normalizeJsonPointer, openGitHubIssueWithCrashReport, operationPagination, operationResponsesMap, parameterWithPagination, parseOpenApiSpec, parseUrl, parseV2_0_X, parseV3_0_X, parseV3_1_X, patchOpenApiSpec, pathToJsonPointer, pathToName, postprocessOutput, printCliIntro, printCrashReport, refToName, resolveNaming, resolveRef, resolveSource, satisfies, shouldReportCrash, statusCodeToGroup, toCase, utils, valueToObject };
 //# sourceMappingURL=index.mjs.map