@workos/oagen 0.14.1 → 0.16.0

package/dist/compat/index.mjs

@@ -1,5 +1,5 @@
 import { t as safeParse$1, v as ExtractorError } from "../tree-sitter-DcUvm0KA.mjs";
-import { A as getDefaultPolicy, C as defaultSeverityForCategory, D as isCompatibleSchemaVersion, E as COMPAT_SCHEMA_VERSION, O as validateSnapshot, S as summarizeChanges, T as apiSurfaceToSnapshot, _ as nodeHints, a as registerExtractor, b as classifyAddedSymbol, c as filterSurface, d as specDerivedHttpKeys, f as specDerivedMethodPaths, g as namedTypeWordsOverlap, h as defaultIsNullableOnlyDifference, i as getExtractor, j as mergePolicy, k as ALL_LANGUAGE_IDS, l as specDerivedEnumValues, m as NAMED_TYPE_RE, n as isPatchableChange, o as diffSnapshots, p as specDerivedNames, r as patchOverlay, s as diffSurfaces, t as buildOverlayLookup, u as specDerivedFieldPaths, v as resolveHints, w as severityMeetsThreshold, x as classifySymbolChanges, y as typeExistsInSurface } from "../overlay-Dlk7bV5R.mjs";
+import { A as getDefaultPolicy, C as defaultSeverityForCategory, D as isCompatibleSchemaVersion, E as COMPAT_SCHEMA_VERSION, O as validateSnapshot, S as summarizeChanges, T as apiSurfaceToSnapshot, _ as nodeHints, a as registerExtractor, b as classifyAddedSymbol, c as filterSurface, d as specDerivedHttpKeys, f as specDerivedMethodPaths, g as namedTypeWordsOverlap, h as defaultIsNullableOnlyDifference, i as getExtractor, j as mergePolicy, k as ALL_LANGUAGE_IDS, l as specDerivedEnumValues, m as NAMED_TYPE_RE, n as isPatchableChange, o as diffSnapshots, p as specDerivedNames, r as patchOverlay, s as diffSurfaces, t as buildOverlayLookup, u as specDerivedFieldPaths, v as resolveHints, w as severityMeetsThreshold, x as classifySymbolChanges, y as typeExistsInSurface } from "../overlay-YkIApOxh.mjs";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import Parser from "tree-sitter";
 import ts from "typescript";
@@ -701,6 +701,7 @@ function parseConstElement(constElement) {
 }
 function parseMethods$2(classBody) {
 	const methods = [];
+	const allPromotedProperties = [];
 	for (const child of classBody.namedChildren) {
 		if (child.type !== "method_declaration") continue;
 		const nameNode = child.childForFieldName("name");
@@ -710,10 +711,11 @@ function parseMethods$2(classBody) {
 		const visibility = getVisibility(child);
 		const isStatic = isStaticMethod(child);
 		const docInfo = findDocComment(child);
+		const promotedProperties = [];
 		const params = [];
 		const paramsList = child.childForFieldName("parameters");
 		if (paramsList) for (const paramNode of paramsList.namedChildren) {
-			if (paramNode.type !== "simple_parameter") continue;
+			if (paramNode.type !== "simple_parameter" && paramNode.type !== "property_promotion_parameter") continue;
 			const paramNameNode = paramNode.namedChildren.find((c) => c.type === "variable_name");
 			if (!paramNameNode) continue;
 			const paramName = paramNameNode.text.replace(/^\$/, "");
@@ -728,6 +730,14 @@ function parseMethods$2(classBody) {
 				type: paramType,
 				optional: hasDefault
 			});
+			if (paramNode.type === "property_promotion_parameter") {
+				const visibility = paramNode.namedChildren.find((c) => c.type === "visibility_modifier")?.text ?? "public";
+				promotedProperties.push({
+					name: paramName,
+					type: paramType,
+					visibility
+				});
+			}
 		}
 		let returnType = "";
 		const returnTypeNode = child.childForFieldName("return_type");
@@ -741,8 +751,12 @@ function parseMethods$2(classBody) {
 			params,
 			returnType
 		});
+		if (methodName === "__construct") allPromotedProperties.push(...promotedProperties);
 	}
-	return methods;
+	return {
+		methods,
+		promotedProperties: allPromotedProperties
+	};
 }
 function parseProperties$1(classBody) {
 	const properties = [];
@@ -815,18 +829,19 @@ function parseClassDeclarations(tree, sourceFile, namespace) {
 		}
 		const bodyNode = node.childForFieldName("body");
 		if (!bodyNode) continue;
-		const methods = parseMethods$2(bodyNode);
+		const { methods, promotedProperties } = parseMethods$2(bodyNode);
 		const properties = parseProperties$1(bodyNode);
 		const constants = parseConstants(bodyNode);
 		const resourceAttributes = parseResourceAttributes(bodyNode);
 		const hasCustomConstructor = methods.some((m) => m.name === "constructFromResponse" && m.isStatic);
+		const allProperties = [...properties, ...promotedProperties];
 		classes.push({
 			name: nameNode.text,
 			namespace,
 			extends: extendsName,
 			isInterface: false,
 			methods,
-			properties,
+			properties: allProperties,
 			constants,
 			resourceAttributes,
 			hasCustomConstructor,
@@ -842,7 +857,7 @@ function parseInterfaceDeclarations(tree, sourceFile, namespace) {
 		if (!nameNode) continue;
 		const bodyNode = node.childForFieldName("body");
 		if (!bodyNode) continue;
-		const methods = parseMethods$2(bodyNode);
+		const { methods } = parseMethods$2(bodyNode);
 		interfaces.push({
 			name: nameNode.text,
 			namespace,
@@ -881,7 +896,7 @@ function parseEnumDeclarations(tree, sourceFile, namespace) {
 				value
 			});
 		}
-		const methods = parseMethods$2(bodyNode);
+		const { methods } = parseMethods$2(bodyNode);
 		enums.push({
 			name: nameNode.text,
 			namespace,
@@ -922,6 +937,27 @@ const DEFAULT_EXCEPTION_BASES$1 = ["Exception", "\\Exception"];
 function isResourceClass(cls, resourceBases) {
 	return !!cls.extends && resourceBases.has(cls.extends) && cls.resourceAttributes.length > 0;
 }
+/**
+* Check if a class is a "value object" — PHP 8 model class whose fields
+* live on the constructor as promoted properties (`public Type $field`).
+* Every model class generated by the WorkOS PHP emitter follows this
+* shape: `readonly class Foo implements \JsonSerializable { use
+* JsonSerializableTrait; public function __construct(public Type $field,
+* …) {} }`. The parser collects promoted properties under
+* `cls.properties` so any class with at least one public promoted
+* property is a value object — the field set is its identity.
+*
+* Exception classes are explicitly excluded: an exception subclass that
+* happens to declare a public property (e.g. `BaseRequestException` with
+* a `$requestId` field) is still semantically an exception, not a model.
+* The `isExceptionClass` check is performed by the caller so this stays
+* a pure structural test.
+*/
+function isValueObjectClass(cls) {
+	if (cls.isInterface) return false;
+	if (cls.constants.length > 0) return false;
+	return cls.properties.some((p) => p.visibility === "public");
+}
 /** Check if a class is enum-like (only constants, no public methods). */
 function isEnumClass(cls) {
 	if (cls.isInterface) return false;
@@ -972,6 +1008,23 @@ function buildSurface$6(allClasses, hints) {
 			...cls.hasCustomConstructor ? { hasCustomConstructor: true } : {}
 		};
 		collector.add(cls.sourceFile, cls.name);
+	} else if (isValueObjectClass(cls) && !isExceptionClass$1(cls, exceptionBases)) {
+		const fields = {};
+		for (const prop of cls.properties) {
+			if (prop.visibility !== "public") continue;
+			fields[prop.name] = {
+				name: prop.name,
+				type: prop.type,
+				optional: false
+			};
+		}
+		interfaces[cls.name] = {
+			name: cls.name,
+			sourceFile: cls.sourceFile,
+			fields,
+			extends: cls.extends ? [cls.extends] : []
+		};
+		collector.add(cls.sourceFile, cls.name);
 	} else if (isEnumClass(cls)) {
 		const members = {};
 		for (const constant of cls.constants) members[constant.name] = constant.value;
@@ -1520,6 +1573,20 @@ const DEFAULT_EXCEPTION_BASES = ["Exception", "BaseException"];
 function hasBase(cls, bases) {
 	return cls.bases.some((b) => bases.has(b));
 }
+/**
+* True when the class carries a `@dataclass` decorator (with or without
+* arguments — `@dataclass`, `@dataclass()`, `@dataclass(slots=True)`, etc.).
+*
+* Dataclasses are the canonical "data-shape" Python construct: their
+* structural identity is the field set, even when generated alongside
+* helper methods like `from_dict` / `to_dict`. Without this signal the
+* extractor categorizes them as plain method-bearing classes (category 5)
+* and loses the field info — which then prevents the compat differ from
+* recognizing renames structurally.
+*/
+function isDataclass(cls) {
+	return cls.decorators.some((d) => /^dataclass(\s*\(.*\))?$/.test(d));
+}
 /** Check if a class is a model class (inherits from BaseModel or configured model bases,
 *  transitively from another class that does). */
 function isModelClass(cls, allClasses, modelBases) {
@@ -1701,6 +1768,22 @@ function buildSurface$5(parsedFiles, hints) {
 				collector.add(cls.sourceFile, cls.name);
 				continue;
 			}
+			if (isDataclass(cls) && cls.fields.length > 0) {
+				const fields = {};
+				for (const field of cls.fields) fields[field.name] = {
+					name: field.name,
+					type: field.type,
+					optional: field.hasDefault
+				};
+				interfaces[cls.name] = {
+					name: cls.name,
+					sourceFile: cls.sourceFile,
+					fields: sortRecord(fields),
+					extends: []
+				};
+				collector.add(cls.sourceFile, cls.name);
+				continue;
+			}
 			if (cls.methods.length > 0) {
 				const apiMethods = {};
 				const constructorParams = [];
@@ -2044,6 +2127,7 @@ function extractClasses(source) {
 		if (node.type !== "class") continue;
 		if (isInsideRanges(node.startPosition.row, serviceRanges)) continue;
 		if (node.descendantsOfType("singleton_class").length > 0) continue;
+		if (isEnumShapedClass(node)) continue;
 		const nameNode = node.childForFieldName("name");
 		if (!nameNode) continue;
 		const className = nameNode.text;
@@ -2100,6 +2184,19 @@ function extractServiceModules(source) {
 	}
 	return services;
 }
+/**
+* True when a `class` node looks like a Ruby enum: only constant
+* assignments, no methods, no attr_*, no singleton class. The
+* `extractEnumModules` pass picks these up; `extractClasses` skips
+* them to avoid double-emission. Shared so the two stay in sync.
+*/
+function isEnumShapedClass(classNode) {
+	const bodyNode = classNode.childForFieldName("body");
+	if (!bodyNode) return false;
+	for (const c of bodyNode.namedChildren) if (c.type === "method" || c.type === "singleton_method" || c.type === "call") return false;
+	const constants = extractEnumConstants(bodyNode);
+	return Object.keys(constants).length >= 2;
+}
 /** Extract enum-like modules (modules with string/number constants, no class << self). */
 function extractEnumModules$1(source) {
 	const tree = safeParse(source);
@@ -2119,6 +2216,22 @@ function extractEnumModules$1(source) {
 			members: sortRecord(constants)
 		});
 	}
+	for (const node of tree.rootNode.descendantsOfType("class")) {
+		if (node.type !== "class") continue;
+		if (isInsideRanges(node.startPosition.row, serviceRanges)) continue;
+		if (node.descendantsOfType("singleton_class").length > 0) continue;
+		const nameNode = node.childForFieldName("name");
+		if (!nameNode) continue;
+		const bodyNode = node.childForFieldName("body");
+		if (!bodyNode) continue;
+		if (bodyNode.namedChildren.some((c) => c.type === "method" || c.type === "singleton_method" || c.type === "call")) continue;
+		const constants = extractEnumConstants(bodyNode);
+		if (Object.keys(constants).length < 2) continue;
+		enums.push({
+			name: nameNode.text,
+			members: sortRecord(constants)
+		});
+	}
 	return enums;
 }
 /** Extract autoload declarations to build the export map. */