@workos/oagen-emitters 0.14.3 → 0.14.4

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-D0qLBiGv.mjs";
+import { t as workosEmittersPlugin } from "./plugin-BGVaMGqe.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.14.3",
+  "version": "0.14.4",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -42,8 +42,8 @@
     "@commitlint/config-conventional": "^21.0.1",
     "@types/node": "^25.9.1",
     "husky": "^9.1.7",
-    "oxfmt": "^0.51.0",
-    "oxlint": "^1.66.0",
+    "oxfmt": "^0.52.0",
+    "oxlint": "^1.67.0",
     "prettier": "^3.8.3",
     "tsdown": "^0.22.0",
     "tsx": "^4.22.3",
@@ -54,6 +54,6 @@
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.20.0"
+    "@workos/oagen": "^0.21.0"
   }
 }

package/src/node/discriminated-models.ts

@@ -124,14 +124,14 @@ export function detectDiscriminatedShape(
       return {
         nameSuffix: variantNameSuffix(discValue),
         discriminatorValue: discValue,
-        fields: variantFields(fv, discProp, modelName, rawSchemas),
+        fields: variantFields(fv, discProp, modelName),
       };
     })
     .filter((v): v is VariantSpec => v !== null);
 
   if (variants.length !== flattenedVariants.length) return null;
 
-  const baseFields = baseObject ? collectObjectFields(baseObject, modelName, rawSchemas) : [];
+  const baseFields = baseObject ? collectObjectFields(baseObject, modelName) : [];
 
   return {
     modelName,
@@ -146,7 +146,7 @@ function mergeBase(prev: RawSchema | null, next: RawSchema): RawSchema {
   if (!prev) return next;
   return {
     type: 'object',
-    properties: { ...(prev.properties ?? {}), ...(next.properties ?? {}) },
+    properties: { ...prev.properties, ...next.properties },
     required: [...new Set([...(prev.required ?? []), ...(next.required ?? [])])],
   };
 }
@@ -328,48 +328,33 @@ function variantNameSuffix(constValue: string): string {
 // Field extraction
 // ---------------------------------------------------------------------------
 
-function collectObjectFields(
-  schema: RawSchema,
-  parentName: string,
-  rawSchemas: Record<string, RawSchema>,
-): FieldSpec[] {
+function collectObjectFields(schema: RawSchema, parentName: string): FieldSpec[] {
   const props = schema.properties ?? {};
   const required = new Set(schema.required ?? []);
   const fields: FieldSpec[] = [];
   for (const [name, propSchema] of Object.entries(props)) {
-    fields.push(buildField(name, propSchema, required.has(name), parentName, rawSchemas));
+    fields.push(buildField(name, propSchema, required.has(name), parentName));
   }
   return fields;
 }
 
-function variantFields(
-  fv: FlattenedVariant,
-  discriminatorProperty: string,
-  parentName: string,
-  rawSchemas: Record<string, RawSchema>,
-): FieldSpec[] {
+function variantFields(fv: FlattenedVariant, discriminatorProperty: string, parentName: string): FieldSpec[] {
   const fields: FieldSpec[] = [];
   for (const [name, propSchema] of fv.alwaysProperties) {
     if (name === discriminatorProperty) continue;
-    fields.push(buildField(name, propSchema, fv.required.has(name), parentName, rawSchemas));
+    fields.push(buildField(name, propSchema, fv.required.has(name), parentName));
   }
   for (const [name, propSchema] of fv.optionalProperties) {
     if (name === discriminatorProperty) continue;
-    fields.push(buildField(name, propSchema, false, parentName, rawSchemas));
+    fields.push(buildField(name, propSchema, false, parentName));
   }
   return fields;
 }
 
-function buildField(
-  rawName: string,
-  schema: RawSchema,
-  required: boolean,
-  parentName: string,
-  rawSchemas: Record<string, RawSchema>,
-): FieldSpec {
+function buildField(rawName: string, schema: RawSchema, required: boolean, parentName: string): FieldSpec {
   const modelDeps = new Set<string>();
-  const domainType = rawSchemaToTS(schema, parentName, rawName, false, modelDeps, rawSchemas);
-  const wireType = rawSchemaToTS(schema, parentName, rawName, true, modelDeps, rawSchemas);
+  const domainType = rawSchemaToTS(schema, parentName, rawName, false, modelDeps);
+  const wireType = rawSchemaToTS(schema, parentName, rawName, true, modelDeps);
   return {
     name: rawName,
     description: schema.description,
@@ -404,7 +389,6 @@ function rawSchemaToTS(
   fieldName: string,
   isWire: boolean,
   modelDeps: Set<string>,
-  rawSchemas: Record<string, RawSchema>,
 ): string {
   if (schema.$ref) {
     const refName = schema.$ref.split('/').pop()!;
@@ -428,7 +412,7 @@ function rawSchemaToTS(
   } else if (baseType === 'boolean') {
     core = 'boolean';
   } else if (baseType === 'array' && schema.items) {
-    const items = rawSchemaToTS(schema.items, parentName, singularize(fieldName), isWire, modelDeps, rawSchemas);
+    const items = rawSchemaToTS(schema.items, parentName, singularize(fieldName), isWire, modelDeps);
     core = `${parenthesizeUnion(items)}[]`;
   } else if (baseType === 'object' && schema.properties) {
     // Inline object — refer to the synthetic model name that

package/src/ruby/rbi.ts

@@ -49,7 +49,7 @@ function mapSorbetType(ref: TypeRef): string {
       if (unique.length === 1) return unique[0];
       return `T.any(${unique.join(', ')})`;
     },
-    nullable: (_ref, inner) => `T.nilable(${inner})`,
+    nullable: (_ref, inner) => wrapNilable(inner),
     literal: (r) =>
       typeof r.value === 'string'
         ? 'String'
@@ -95,7 +95,7 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
       const fname = fieldName(f.name);
       if (seenFieldNames.has(fname)) continue;
       seenFieldNames.add(fname);
-      const sorbetType = f.required ? mapSorbetType(f.type) : `T.nilable(${unwrapNilable(mapSorbetType(f.type))})`;
+      const sorbetType = f.required ? mapSorbetType(f.type) : wrapNilable(mapSorbetType(f.type));
       lines.push(`    sig { returns(${sorbetType}) }`);
       lines.push(`    def ${fname}; end`);
       lines.push('');
@@ -238,7 +238,7 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
         const n = fieldName(f.name);
         if (seen.has(n)) continue;
         seen.add(n);
-        sigParams.push(`${n}: T.nilable(${unwrapNilable(mapSorbetType(f.type))})`);
+        sigParams.push(`${n}: ${wrapNilable(mapSorbetType(f.type))}`);
       }
       for (const q of queryParams) {
         if (hiddenParams.has(q.name)) continue;
@@ -246,14 +246,14 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
         const n = safeParamName(q.name);
         if (seen.has(n)) continue;
         seen.add(n);
-        sigParams.push(`${n}: T.nilable(${unwrapNilable(mapSorbetType(q.type))})`);
+        sigParams.push(`${n}: ${wrapNilable(mapSorbetType(q.type))}`);
       }
       for (const group of parameterGroups) {
         if (!group.optional) continue;
         const n = fieldName(group.name);
         if (seen.has(n)) continue;
         seen.add(n);
-        sigParams.push(`${n}: T.nilable(${groupSorbetType(group)})`);
+        sigParams.push(`${n}: ${wrapNilable(groupSorbetType(group))}`);
       }
       sigParams.push('request_options: T::Hash[Symbol, T.untyped]');
 
@@ -321,6 +321,12 @@ function unwrapNilable(type: string): string {
   return match ? match[1] : type;
 }
 
+/** Wrap a type in T.nilable(), skipping T.untyped (which already includes nil) and avoiding double-wrapping. */
+function wrapNilable(type: string): string {
+  if (type === 'T.untyped') return type;
+  return `T.nilable(${unwrapNilable(type)})`;
+}
+
 /** Map a response TypeRef to a Sorbet return type. */
 function mapSorbetReturnType(ref: TypeRef, listWrapperModels: Map<string, Model>, modelNames: Set<string>): string {
   if (ref.kind === 'model' && listWrapperModels.has(ref.name)) {
@@ -333,7 +339,7 @@ function mapSorbetReturnType(ref: TypeRef, listWrapperModels: Map<string, Model>
     return `T::Array[WorkOS::${className(ref.items.name)}]`;
   }
   if (ref.kind === 'nullable') {
-    return `T.nilable(${mapSorbetReturnType(ref.inner, listWrapperModels, modelNames)})`;
+    return wrapNilable(mapSorbetReturnType(ref.inner, listWrapperModels, modelNames));
   }
   if (ref.kind === 'primitive' && ref.type === 'unknown') {
     return 'NilClass';