@formspec/build 0.1.0-alpha.36 → 0.1.0-alpha.37

package/dist/generators/discovered-schema.d.ts

@@ -106,6 +106,8 @@ export declare function generateSchemasFromParameter(options: GenerateSchemasFro
 /**
  * Generates schemas for a method or function return type.
  *
+ * Awaited `Promise<T>`-style return types are unwrapped before generation.
+ *
  * @public
  */
 export declare function generateSchemasFromReturnType(options: GenerateSchemasFromReturnTypeOptions): DiscoveredTypeSchemas;

package/dist/generators/discovered-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovered-schema.d.ts","sourceRoot":"","sources":["../../src/generators/discovered-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAQjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAU7D,OAAO,EAGL,KAAK,6BAA6B,EACnC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAK/F;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAC/B,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,oBAAoB,GACvB,EAAE,CAAC,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,qCAAsC,SAAQ,6BAA6B;IAC1F,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,uBAAuB,CAAC;CAC/C;AAED;;;;GAIG;AACH,MAAM,WAAW,8BAA+B,SAAQ,6BAA6B;IACnF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,CAAC;IAC1C,sDAAsD;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,WAAW,mCAAoC,SAAQ,6BAA6B;IACxF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,oBAAoB,CAAC;CAC7C;AAED;;;;GAIG;AACH,MAAM,WAAW,oCAAqC,SAAQ,6BAA6B;IACzF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC,oBAAoB,CAAC;CAC/C;AAwSD;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qCAAqC,GAC7C,qBAAqB,CA+EvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,8BAA8B,GACtC,qBAAqB,CAEvB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mCAAmC,GAC3C,qBAAqB,CAOvB;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,oCAAoC,GAC5C,qBAAqB,CAkBvB"}
+{"version":3,"file":"discovered-schema.d.ts","sourceRoot":"","sources":["../../src/generators/discovered-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAQjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAU7D,OAAO,EAGL,KAAK,6BAA6B,EACnC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAK/F;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAC/B,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,oBAAoB,GACvB,EAAE,CAAC,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,qCAAsC,SAAQ,6BAA6B;IAC1F,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,uBAAuB,CAAC;CAC/C;AAED;;;;GAIG;AACH,MAAM,WAAW,8BAA+B,SAAQ,6BAA6B;IACnF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,CAAC;IAC1C,sDAAsD;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,WAAW,mCAAoC,SAAQ,6BAA6B;IACxF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,oBAAoB,CAAC;CAC7C;AAED;;;;GAIG;AACH,MAAM,WAAW,oCAAqC,SAAQ,6BAA6B;IACzF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC,oBAAoB,CAAC;CAC/C;AAwSD;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qCAAqC,GAC7C,qBAAqB,CA+EvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,8BAA8B,GACtC,qBAAqB,CAEvB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mCAAmC,GAC3C,qBAAqB,CAOvB;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,oCAAoC,GAC5C,qBAAqB,CAyBvB"}

package/dist/index.cjs

@@ -2925,6 +2925,21 @@ function isObjectType(type) {
 function isIntersectionType(type) {
   return !!(type.flags & ts3.TypeFlags.Intersection);
 }
+function isResolvableObjectLikeAliasTypeNode(typeNode) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
+    return isResolvableObjectLikeAliasTypeNode(typeNode.type);
+  }
+  if (ts3.isTypeLiteralNode(typeNode) || ts3.isTypeReferenceNode(typeNode)) {
+    return true;
+  }
+  return ts3.isIntersectionTypeNode(typeNode) && typeNode.types.length > 0 && typeNode.types.every((member) => isResolvableObjectLikeAliasTypeNode(member));
+}
+function isSemanticallyPlainObjectLikeType(type, checker) {
+  if (isIntersectionType(type)) {
+    return type.types.length > 0 && type.types.every((member) => isSemanticallyPlainObjectLikeType(member, checker));
+  }
+  return isObjectType(type) && checker.getSignaturesOfType(type, ts3.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, ts3.SignatureKind.Construct).length === 0 && !checker.isArrayType(type) && !checker.isTupleType(type);
+}
 function isTypeReference(type) {
   return !!(type.flags & ts3.TypeFlags.Object) && !!(type.objectFlags & ts3.ObjectFlags.Reference);
 }
@@ -3182,6 +3197,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
     const kindDesc = ts3.SyntaxKind[typeAlias.type.kind] ?? "unknown";
     return {
       ok: false,
+      kind: "not-object-like",
       error: `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} is not an object-like type alias (found ${kindDesc})`
     };
   }
@@ -3196,6 +3212,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
     const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
     return {
       ok: false,
+      kind: "duplicate-properties",
       error: `Type alias "${name}" at line ${String(line + 1)} contains duplicate property names across object-like members: ${duplicatePropertyNames.join(", ")}`
     };
   }
@@ -3892,10 +3909,10 @@ function findDuplicateObjectLikeTypeAliasPropertyNames(members) {
   return [...duplicates].sort();
 }
 function getAnalyzableObjectLikePropertyName(name) {
-  if (!ts3.isIdentifier(name)) {
-    return null;
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+    return name.text;
   }
-  return name.text;
+  return null;
 }
 function applyEnumMemberDisplayNames(type, annotations) {
   if (!annotations.some(
@@ -4105,6 +4122,19 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
         diagnostics
       );
     }
+    if (resolvedSourceTypeNode !== void 0 && isResolvableObjectLikeAliasTypeNode(resolvedSourceTypeNode) && isSemanticallyPlainObjectLikeType(type, checker)) {
+      return resolveObjectType(
+        type,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        sourceNode,
+        metadataPolicy,
+        extensionRegistry,
+        diagnostics
+      );
+    }
   }
   if (isObjectType(type)) {
     return resolveObjectType(
@@ -5012,6 +5042,95 @@ function findInterfaceByName(sourceFile, interfaceName) {
 function findTypeAliasByName(sourceFile, aliasName) {
   return findNodeByName(sourceFile, aliasName, ts4.isTypeAliasDeclaration, (n) => n.name.text);
 }
+function getResolvedObjectRootType(rootType, typeRegistry) {
+  if (rootType.kind === "object") {
+    return rootType;
+  }
+  if (rootType.kind !== "reference") {
+    return null;
+  }
+  const definition = typeRegistry[rootType.name];
+  return definition?.type.kind === "object" ? definition.type : null;
+}
+function createResolvedObjectAliasAnalysis(name, rootType, typeRegistry, rootInfo, diagnostics) {
+  const resolvedRootType = getResolvedObjectRootType(rootType, typeRegistry);
+  if (resolvedRootType === null) {
+    return null;
+  }
+  const fields = resolvedRootType.properties.map((property) => ({
+    kind: "field",
+    name: property.name,
+    ...property.metadata !== void 0 && { metadata: property.metadata },
+    type: property.type,
+    required: !property.optional,
+    constraints: property.constraints,
+    annotations: property.annotations,
+    provenance: property.provenance
+  }));
+  return {
+    name,
+    ...rootInfo.metadata !== void 0 && { metadata: rootInfo.metadata },
+    fields,
+    fieldLayouts: fields.map(() => ({})),
+    typeRegistry,
+    ...rootInfo.annotations.length > 0 && { annotations: [...rootInfo.annotations] },
+    ...diagnostics.length > 0 && { diagnostics: [...diagnostics] },
+    instanceMethods: [],
+    staticMethods: []
+  };
+}
+function containsTypeReferenceInObjectLikeAlias(typeNode) {
+  if (ts4.isParenthesizedTypeNode(typeNode)) {
+    return containsTypeReferenceInObjectLikeAlias(typeNode.type);
+  }
+  if (ts4.isTypeReferenceNode(typeNode)) {
+    return true;
+  }
+  return ts4.isIntersectionTypeNode(typeNode) && typeNode.types.some((member) => containsTypeReferenceInObjectLikeAlias(member));
+}
+function collectFallbackAliasMemberPropertyNames(typeNode, checker) {
+  if (ts4.isParenthesizedTypeNode(typeNode)) {
+    return collectFallbackAliasMemberPropertyNames(typeNode.type, checker);
+  }
+  if (ts4.isTypeLiteralNode(typeNode)) {
+    const propertyNames = [];
+    for (const member of typeNode.members) {
+      if (!ts4.isPropertySignature(member)) {
+        continue;
+      }
+      const propertyName = getAnalyzableObjectLikePropertyName(member.name);
+      if (propertyName !== null) {
+        propertyNames.push(propertyName);
+      }
+    }
+    return propertyNames;
+  }
+  if (ts4.isTypeReferenceNode(typeNode)) {
+    return checker.getTypeFromTypeNode(typeNode).getProperties().map((property) => property.getName());
+  }
+  return null;
+}
+function findFallbackAliasDuplicatePropertyNames(typeNode, checker) {
+  if (!ts4.isIntersectionTypeNode(typeNode)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const member of typeNode.types) {
+    const propertyNames = collectFallbackAliasMemberPropertyNames(member, checker);
+    if (propertyNames === null) {
+      continue;
+    }
+    for (const propertyName of propertyNames) {
+      if (seen.has(propertyName)) {
+        duplicates.add(propertyName);
+      } else {
+        seen.add(propertyName);
+      }
+    }
+  }
+  return [...duplicates].sort();
+}
 function analyzeNamedTypeToIR(filePath, typeName, extensionRegistry, metadataPolicy, discriminatorOptions) {
   const ctx = createProgramContext(filePath);
   return analyzeNamedTypeToIRFromProgramContext(
@@ -5060,6 +5179,51 @@ function analyzeNamedTypeToIRFromProgramContext(ctx, filePath, typeName, extensi
     if (result.ok) {
       return result.analysis;
     }
+    const fallbackEligible = result.kind === "not-object-like" && isResolvableObjectLikeAliasTypeNode(typeAlias.type) && containsTypeReferenceInObjectLikeAlias(typeAlias.type);
+    if (!fallbackEligible) {
+      throw new Error(result.error);
+    }
+    const duplicatePropertyNames = findFallbackAliasDuplicatePropertyNames(
+      typeAlias.type,
+      ctx.checker
+    );
+    if (duplicatePropertyNames.length > 0) {
+      const sourceFile = typeAlias.getSourceFile();
+      const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
+      throw new Error(
+        `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} contains duplicate property names across object-like members: ${duplicatePropertyNames.join(", ")}`
+      );
+    }
+    const rootInfo = analyzeDeclarationRootInfo(
+      typeAlias,
+      ctx.checker,
+      analysisFilePath,
+      extensionRegistry,
+      metadataPolicy
+    );
+    const diagnostics = [...rootInfo.diagnostics];
+    const typeRegistry = {};
+    const rootType = resolveTypeNode(
+      ctx.checker.getTypeAtLocation(typeAlias),
+      ctx.checker,
+      analysisFilePath,
+      typeRegistry,
+      /* @__PURE__ */ new Set(),
+      typeAlias,
+      createAnalyzerMetadataPolicy(metadataPolicy, discriminatorOptions),
+      extensionRegistry,
+      diagnostics
+    );
+    const fallbackAnalysis = createResolvedObjectAliasAnalysis(
+      typeAlias.name.text,
+      rootType,
+      typeRegistry,
+      rootInfo,
+      diagnostics
+    );
+    if (fallbackAnalysis !== null) {
+      return fallbackAnalysis;
+    }
     throw new Error(result.error);
   }
   throw new Error(
@@ -5563,15 +5727,36 @@ function generateSchemasFromParameter(options) {
 }
 function generateSchemasFromReturnType(options) {
   const signature = options.context.checker.getSignatureFromDeclaration(options.declaration);
-  const type = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
+  const returnType = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
+  const type = unwrapPromiseType(options.context.checker, returnType);
+  const sourceNode = type !== returnType ? unwrapPromiseTypeNode(options.declaration.type) ?? options.declaration.type ?? options.declaration : options.declaration.type ?? options.declaration;
   const fallbackName = options.declaration.name !== void 0 && ts7.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
   return generateSchemasFromResolvedType({
     ...options,
     type,
-    sourceNode: options.declaration.type ?? options.declaration,
+    sourceNode,
     name: fallbackName
   });
 }
+function unwrapPromiseType(checker, type) {
+  if (!("getAwaitedType" in checker) || typeof checker.getAwaitedType !== "function") {
+    return type;
+  }
+  return checker.getAwaitedType(type) ?? type;
+}
+function unwrapPromiseTypeNode(typeNode) {
+  if (typeNode === void 0) {
+    return void 0;
+  }
+  if (ts7.isParenthesizedTypeNode(typeNode)) {
+    const unwrapped = unwrapPromiseTypeNode(typeNode.type);
+    return unwrapped ?? typeNode;
+  }
+  return isPromiseTypeReferenceNode(typeNode) ? typeNode.typeArguments[0] : typeNode;
+}
+function isPromiseTypeReferenceNode(typeNode) {
+  return ts7.isTypeReferenceNode(typeNode) && ts7.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
+}
 
 // src/generators/mixed-authoring.ts
 function buildMixedAuthoringSchemas(options) {