@hey-api/shared 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -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,