@effect/language-service 0.60.0 → 0.62.0

package/index.js

@@ -869,6 +869,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   return [];
 });
 var dedupe = (self) => dedupeWith(self, equivalence());
+var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
 // node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Chunk.js
 var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Chunk");
@@ -4478,7 +4479,11 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
     service(ChangeTracker),
     map8((changeTracker) => {
       changeTracker.deleteRange(sourceFile, range);
-      changeTracker.insertText(sourceFile, range.pos, `${codegen.name}:${edit.hash}`);
+      changeTracker.insertText(
+        sourceFile,
+        range.pos,
+        edit.hash.length > 0 ? `${codegen.name}:${edit.hash}` : codegen.name
+      );
     })
   );
   return {
@@ -4590,6 +4595,9 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   function isThisTypeParameter(type) {
     return !!(type.flags & ts.TypeFlags.TypeParameter && type.isThisType);
   }
+  function isMissingIntrinsicType(type) {
+    return (type.flags & ts.TypeFlags.Undefined) !== 0 && "debugIntrinsicName" in type && type.debugIntrinsicName === "missing";
+  }
   function getTypeParameterAtPosition(signature, pos) {
     const type = typeChecker.getParameterType(signature, pos);
     if (isIndexType(type) && isThisTypeParameter(type.type)) {
@@ -4894,6 +4902,7 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   }
   return {
     isUnion,
+    isMissingIntrinsicType,
     getTypeParameterAtPosition,
     getMissingTypeEntriesInTargetType,
     unrollUnionMembers,
@@ -6531,8 +6540,662 @@ var annotate = createCodegen({
   })
 });
 
+// src/utils/StructuralSchemaGen.ts
+var UnsupportedTypeError = class {
+  constructor(type, reason) {
+    this.type = type;
+    this.reason = reason;
+  }
+  _tag = "@effect/language-service/UnsupportedTypeError";
+  toString() {
+    return `Unsupported type: ${this.reason}`;
+  }
+};
+var StructuralSchemaGenContext = Tag("StructuralSchemaGenContext");
+var makeStructuralSchemaGenContext = fn("StructuralSchemaGen.makeContext")(
+  function* (sourceFile, schemaIdentifier) {
+    const ts = yield* service(TypeScriptApi);
+    const program = yield* service(TypeScriptProgram);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const effectSchemaIdentifier = schemaIdentifier || "Schema";
+    return identity({
+      ts,
+      program,
+      typeChecker,
+      typeCheckerUtils,
+      sourceFile,
+      createApiPropertyAccess: (apiName) => ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectSchemaIdentifier),
+        apiName
+      ),
+      createApiCall: (apiName, args2) => ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectSchemaIdentifier),
+          apiName
+        ),
+        [],
+        args2
+      ),
+      hoistedSchemas: /* @__PURE__ */ new Map(),
+      typeToStatementIndex: /* @__PURE__ */ new Map(),
+      nameToType: /* @__PURE__ */ new Map(),
+      usedGlobalIdentifiers: /* @__PURE__ */ new Map(),
+      schemaStatements: [],
+      rangesToDelete: []
+    });
+  }
+);
+var pushHoistedStatement = fn("StructuralSchemaGen.pushHoistedStatement")(
+  function* (ctx, name, type, statement, createReference) {
+    ctx.usedGlobalIdentifiers.set(name, (ctx.usedGlobalIdentifiers.get(name) || 0) + 1);
+    ctx.schemaStatements.push(statement);
+    ctx.typeToStatementIndex.set(type, ctx.schemaStatements.length - 1);
+    ctx.hoistedSchemas.set(type, createReference);
+  }
+);
+var pushHoistedVariableStatement = fn("StructuralSchemaGen.pushHoistedVariableStatement")(
+  function* (ts, ctx, name, type, result) {
+    return yield* pushHoistedStatement(
+      ctx,
+      name,
+      type,
+      ts.factory.createVariableStatement(
+        void 0,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(ts.factory.createIdentifier(name), void 0, void 0, result)],
+          ts.NodeFlags.Const
+        )
+      ),
+      () => ts.factory.createIdentifier(name)
+    );
+  }
+);
+var createProcessingContext = (maxDepth = 200) => ({
+  depth: 0,
+  maxDepth,
+  hoistName: void 0
+});
+var processType = fn(
+  "StructuralSchemaGen.processType"
+)(
+  function* (type, context) {
+    const processingContext = context || createProcessingContext();
+    const { hoistedSchemas, nameToType, ts, typeChecker, usedGlobalIdentifiers } = yield* service(
+      StructuralSchemaGenContext
+    );
+    if (processingContext.depth >= processingContext.maxDepth) {
+      return yield* fail3(new UnsupportedTypeError(type, "Maximum depth exceeded"));
+    }
+    let hoistName = fromIterable(nameToType.entries()).find(([_, existingType]) => existingType === type)?.[0];
+    if (!hoistName && type && type.symbol && type.symbol.declarations && type.symbol.declarations.length === 1) {
+      const declaration = type.symbol.declarations[0];
+      if (ts.isInterfaceDeclaration(declaration)) {
+        hoistName = ts.idText(declaration.name);
+      } else if (declaration.parent && ts.isTypeAliasDeclaration(declaration.parent)) {
+        hoistName = ts.idText(declaration.parent.name);
+      }
+      if (hoistName) {
+        const existingType = nameToType.get(hoistName);
+        const isSame = existingType && typeChecker.isTypeAssignableTo(type, existingType) && typeChecker.isTypeAssignableTo(existingType, type);
+        if (!isSame) {
+          const usedCount = usedGlobalIdentifiers.get(hoistName) || 0;
+          hoistName = usedCount > 0 ? hoistName + "_" + usedCount : hoistName;
+        }
+      }
+    }
+    const nestedContext = {
+      ...processingContext,
+      depth: processingContext.depth + 1,
+      hoistName
+    };
+    for (const [hoistedType, hoistedSchema] of hoistedSchemas.entries()) {
+      if (hoistedType === type || typeChecker.isTypeAssignableTo(type, hoistedType) && typeChecker.isTypeAssignableTo(hoistedType, type)) {
+        return hoistedSchema();
+      }
+    }
+    const [schemaExpr, skipHoisting] = yield* processTypeImpl(type, nestedContext);
+    if (!skipHoisting && hoistName) {
+      const ctx = yield* service(StructuralSchemaGenContext);
+      yield* pushHoistedVariableStatement(ts, ctx, hoistName, type, schemaExpr);
+      return ctx.hoistedSchemas.get(type)();
+    }
+    return schemaExpr;
+  }
+);
+var processTypeImpl = fn(
+  "StructuralSchemaGen.processTypeImpl"
+)(
+  function* (type, context) {
+    const { createApiCall, createApiPropertyAccess, ts, typeChecker, typeCheckerUtils } = yield* service(
+      StructuralSchemaGenContext
+    );
+    if (type.flags & ts.TypeFlags.String) {
+      return [createApiPropertyAccess("String"), true];
+    }
+    if (type.flags & ts.TypeFlags.Number) {
+      return [createApiPropertyAccess("Number"), true];
+    }
+    if (type.flags & ts.TypeFlags.Boolean) {
+      return [createApiPropertyAccess("Boolean"), true];
+    }
+    if (type.flags & ts.TypeFlags.BigInt) {
+      return [createApiPropertyAccess("BigInt"), true];
+    }
+    if (type.flags & ts.TypeFlags.Void) {
+      return [createApiPropertyAccess("Void"), true];
+    }
+    if (type.flags & ts.TypeFlags.Undefined) {
+      return [createApiPropertyAccess("Undefined"), true];
+    }
+    if (type.flags & ts.TypeFlags.Null) {
+      return [createApiPropertyAccess("Null"), true];
+    }
+    if (type.flags & ts.TypeFlags.Never) {
+      return [createApiPropertyAccess("Never"), true];
+    }
+    if (type.flags & ts.TypeFlags.Any) {
+      return [createApiPropertyAccess("Any"), true];
+    }
+    if (type.flags & ts.TypeFlags.Unknown) {
+      return [createApiPropertyAccess("Unknown"), true];
+    }
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+      const literalType = type;
+      return [createApiCall("Literal", [ts.factory.createStringLiteral(literalType.value)]), true];
+    }
+    if (type.flags & ts.TypeFlags.NumberLiteral) {
+      const literalType = type;
+      return [createApiCall("Literal", [ts.factory.createNumericLiteral(literalType.value)]), true];
+    }
+    if (type.flags & ts.TypeFlags.BooleanLiteral) {
+      const value = type.intrinsicName === "true";
+      return [createApiCall("Literal", [value ? ts.factory.createTrue() : ts.factory.createFalse()]), true];
+    }
+    if (typeCheckerUtils.isUnion(type)) {
+      return yield* processUnionType(type.types, context);
+    }
+    if (type.flags & ts.TypeFlags.Intersection) {
+      return yield* processIntersectionType(type, context);
+    }
+    if (typeChecker.isArrayType(type)) {
+      return yield* processArrayType(type, context);
+    }
+    if (typeChecker.isTupleType(type)) {
+      return yield* processTupleType(type, context);
+    }
+    if (type.flags & ts.TypeFlags.Object) {
+      const symbol3 = type.symbol || type.aliasSymbol;
+      if (symbol3) {
+        const typeName = typeChecker.symbolToString(symbol3);
+        if (typeName === "Date") {
+          return [createApiPropertyAccess("Date"), false];
+        }
+        if (typeName === "ReadonlyArray" || typeName === "Array") {
+          return yield* processArrayType(type, context);
+        }
+      }
+      const objectType = type;
+      return yield* processObjectType(objectType, context);
+    }
+    return yield* fail3(
+      new UnsupportedTypeError(
+        type,
+        `Type with flags ${type.flags} is not supported`
+      )
+    );
+  }
+);
+var processUnionType = fn(
+  "StructuralSchemaGen.processUnionType"
+)(
+  function* (types, context) {
+    const { createApiCall, ts } = yield* service(StructuralSchemaGenContext);
+    const allLiterals = types.every(
+      (t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral
+    );
+    if (allLiterals) {
+      const literals = yield* all(
+        ...types.map((t) => processType(t, context))
+      );
+      const literalValues = literals.map((expr) => {
+        if (ts.isCallExpression(expr) && expr.arguments.length > 0) {
+          return expr.arguments[0];
+        }
+        return expr;
+      }).filter((arg) => arg !== void 0);
+      return [createApiCall("Literal", literalValues), false];
+    }
+    const members = yield* all(
+      ...types.map((t) => processType(t, context))
+    );
+    if (members.length === 1) {
+      return [members[0], false];
+    }
+    return [createApiCall("Union", members), false];
+  }
+);
+var processIntersectionType = fn(
+  "StructuralSchemaGen.processIntersectionType"
+)(
+  function* (type, context) {
+    const { createApiCall, ts } = yield* service(StructuralSchemaGenContext);
+    const [firstSchema, ...otherSchemas] = yield* all(
+      ...type.types.map((t) => processType(t, context))
+    );
+    if (otherSchemas.length === 0) {
+      return [firstSchema, false];
+    }
+    return [
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          firstSchema,
+          "pipe"
+        ),
+        [],
+        otherSchemas.map((schema) => createApiCall("extend", [schema]))
+      ),
+      false
+    ];
+  }
+);
+var processArrayType = fn(
+  "StructuralSchemaGen.processArrayType"
+)(
+  function* (type, context) {
+    const { createApiCall, typeChecker } = yield* service(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type);
+    if (typeArgs.length === 0) {
+      return yield* fail3(new UnsupportedTypeError(type, "Array type has no type arguments"));
+    }
+    const elementSchema = yield* processType(typeArgs[0], context);
+    return [createApiCall("Array", [elementSchema]), false];
+  }
+);
+var processTupleType = fn(
+  "StructuralSchemaGen.processTupleType"
+)(
+  function* (type, context) {
+    const { createApiCall, typeChecker } = yield* service(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type);
+    const elementSchemas = yield* all(
+      ...typeArgs.map((t) => processType(t, context))
+    );
+    return [createApiCall("Tuple", elementSchemas), false];
+  }
+);
+var processObjectType = fn(
+  "StructuralSchemaGen.processObjectType"
+)(
+  function* (type, context) {
+    const {
+      createApiCall,
+      createApiPropertyAccess,
+      program,
+      ts,
+      typeChecker,
+      typeCheckerUtils
+    } = yield* service(
+      StructuralSchemaGenContext
+    );
+    let hasRecords = false;
+    const properties = typeChecker.getPropertiesOfType(type);
+    const propertyAssignments = [];
+    for (const property of properties) {
+      const propertyName = typeChecker.symbolToString(property);
+      const propertyType = typeChecker.getTypeOfSymbol(property);
+      const isOptional = (property.flags & ts.SymbolFlags.Optional) !== 0;
+      let schemaExpr;
+      if (isOptional) {
+        if (program.getCompilerOptions().exactOptionalPropertyTypes) {
+          if (typeCheckerUtils.isUnion(propertyType)) {
+            const typeWithoutMissing = propertyType.types.filter((t) => !typeCheckerUtils.isMissingIntrinsicType(t));
+            const [result, _] = yield* processUnionType(typeWithoutMissing, context);
+            schemaExpr = createApiCall("optionalWith", [
+              result,
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("exact", ts.factory.createTrue())
+              ])
+            ]);
+          }
+        } else {
+          schemaExpr = yield* processType(propertyType, context);
+          schemaExpr = createApiCall("optional", [schemaExpr]);
+        }
+      }
+      if (!schemaExpr) {
+        schemaExpr = yield* processType(propertyType, context);
+      }
+      const propertyNameNode = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propertyName) ? ts.factory.createIdentifier(propertyName) : ts.factory.createStringLiteral(propertyName);
+      propertyAssignments.push(
+        ts.factory.createPropertyAssignment(
+          propertyNameNode,
+          schemaExpr
+        )
+      );
+    }
+    const indexInfos = typeChecker.getIndexInfosOfType(type);
+    const args2 = [
+      ts.factory.createObjectLiteralExpression(propertyAssignments, propertyAssignments.length > 0)
+    ];
+    for (const indexInfo of indexInfos) {
+      hasRecords = true;
+      const keyType = indexInfo.keyType;
+      const valueType = indexInfo.type;
+      const keySchema = yield* processType(keyType, context);
+      const valueSchema = yield* processType(valueType, context);
+      args2.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", keySchema),
+          ts.factory.createPropertyAssignment("value", valueSchema)
+        ])
+      );
+    }
+    if (!hasRecords && context.hoistName) {
+      const ctx = yield* service(StructuralSchemaGenContext);
+      yield* pushHoistedStatement(
+        ctx,
+        context.hoistName,
+        type,
+        ts.factory.createClassDeclaration(
+          void 0,
+          ts.factory.createIdentifier(context.hoistName),
+          [],
+          [ts.factory.createHeritageClause(
+            ts.SyntaxKind.ExtendsKeyword,
+            [
+              ts.factory.createExpressionWithTypeArguments(
+                ts.factory.createCallExpression(
+                  ts.factory.createCallExpression(
+                    createApiPropertyAccess("Class"),
+                    [ts.factory.createTypeReferenceNode(
+                      context.hoistName
+                    )],
+                    [ts.factory.createStringLiteral(context.hoistName)]
+                  ),
+                  [],
+                  args2
+                ),
+                []
+              )
+            ]
+          )],
+          []
+        ),
+        () => ts.factory.createIdentifier(context.hoistName)
+      );
+      return [ctx.hoistedSchemas.get(type)(), true];
+    }
+    return [createApiCall("Struct", args2), propertyAssignments.length === 0];
+  }
+);
+var findNodeToProcess = fn("StructuralSchemaGen.findNodeToProcess")(
+  function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    return pipe(
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      filter((node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)),
+      filter((node) => tsUtils.isNodeInRange(textRange)(node.name)),
+      filter((node) => (node.typeParameters || []).length === 0),
+      map4((node) => ({
+        node,
+        identifier: node.name,
+        type: typeChecker.getTypeAtLocation(node.name),
+        isExported: node.modifiers ? (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 : false
+      })),
+      filter(({ type }) => !!type),
+      head
+    );
+  }
+);
+var process = fn("StructuralSchemaGen.process")(
+  function* (sourceFile, scope, typeMap, isExported, handleCodegeneratedComments) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Schema") || "Schema";
+    const ctx = yield* makeStructuralSchemaGenContext(sourceFile, schemaIdentifier);
+    for (const [name, type] of typeMap.entries()) {
+      ctx.nameToType.set(name, type);
+    }
+    if (handleCodegeneratedComments) {
+      for (const declaration of sourceFile.statements) {
+        const nodeText = sourceFile.text.slice(declaration.pos, declaration.end);
+        if (!nodeText.toLowerCase().includes("@effect-schema-codegenerated")) continue;
+        const interleavingRange = ctx.rangesToDelete.find(
+          (range) => range.pos < declaration.end && range.end > declaration.pos
+        );
+        if (interleavingRange) {
+          interleavingRange.pos = Math.min(interleavingRange.pos, declaration.pos);
+          interleavingRange.end = Math.max(interleavingRange.end, declaration.end);
+        } else {
+          ctx.rangesToDelete.push({
+            pos: declaration.pos,
+            end: declaration.end
+          });
+        }
+      }
+    }
+    for (const symbol3 of typeChecker.getSymbolsInScope(scope, ts.SymbolFlags.Value)) {
+      const name = typeChecker.symbolToString(symbol3);
+      ctx.usedGlobalIdentifiers.set(name, 1);
+      const type = typeChecker.getTypeOfSymbolAtLocation(symbol3, sourceFile);
+      if (type) {
+        const schemaType = yield* pipe(
+          typeParser.effectSchemaType(type, scope),
+          orElse2(() => void_)
+        );
+        if (schemaType) {
+          ctx.hoistedSchemas.set(
+            schemaType.A,
+            () => {
+              const expression = typeChecker.symbolToExpression(
+                symbol3,
+                ts.SymbolFlags.Value,
+                scope,
+                ts.NodeBuilderFlags.NoTruncation
+              );
+              if (expression) {
+                return expression;
+              }
+              return ts.factory.createIdentifier(name);
+            }
+          );
+        }
+      }
+    }
+    const results = yield* pipe(
+      all(
+        ...fromIterable(ctx.nameToType.entries()).map(
+          ([name, type]) => pipe(
+            processType(type),
+            orElse2(
+              (error) => succeed(ts.addSyntheticLeadingComment(
+                ts.factory.createIdentifier(""),
+                ts.SyntaxKind.MultiLineCommentTrivia,
+                " " + String(error) + " ",
+                true
+              ))
+            ),
+            map8((_) => ({ requestedName: name, type, result: _ }))
+          )
+        )
+      ),
+      provideService(StructuralSchemaGenContext, ctx)
+    );
+    for (const { requestedName, result, type } of results) {
+      const statementIndex = ctx.typeToStatementIndex.get(type);
+      if (statementIndex !== void 0) continue;
+      ctx.schemaStatements.push(ts.factory.createVariableStatement(
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
+            ts.factory.createIdentifier(requestedName),
+            void 0,
+            void 0,
+            result
+          )],
+          ts.NodeFlags.Const
+        )
+      ));
+      ctx.typeToStatementIndex.set(type, ctx.schemaStatements.length - 1);
+    }
+    if (isExported) {
+      const statementsToExport = pipe(
+        fromIterable(ctx.nameToType),
+        map4(([_, type]) => ctx.typeToStatementIndex.get(type)),
+        filter((index) => index !== void 0),
+        dedupe
+      );
+      for (let i = 0; i < ctx.schemaStatements.length; i++) {
+        if (!statementsToExport.includes(i)) continue;
+        const statement = ctx.schemaStatements[i];
+        if (ts.isVariableStatement(statement)) {
+          ctx.schemaStatements[i] = ts.factory.updateVariableStatement(
+            statement,
+            ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export),
+            statement.declarationList
+          );
+        } else if (ts.isClassDeclaration(statement)) {
+          ctx.schemaStatements[i] = ts.factory.updateClassDeclaration(
+            statement,
+            ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export),
+            statement.name,
+            statement.typeParameters,
+            statement.heritageClauses,
+            statement.members
+          );
+        }
+      }
+    }
+    if (handleCodegeneratedComments) {
+      for (let i = 0; i < ctx.schemaStatements.length; i++) {
+        const statement = ctx.schemaStatements[i];
+        ctx.schemaStatements[i] = ts.addSyntheticLeadingComment(
+          statement,
+          ts.SyntaxKind.SingleLineCommentTrivia,
+          " @effect-schema-codegenerated: This schema will be re-generated by the effect-schema-codegens command, remove this comment to disable re-generation.",
+          true
+        );
+      }
+    }
+    return ctx;
+  }
+);
+var applyAtNode = fn("StructuralSchemaGen.applyAtNode")(
+  function* (sourceFile, node, identifier, type, isExported) {
+    const changeTracker = yield* service(ChangeTracker);
+    const ts = yield* service(TypeScriptApi);
+    const ctx = yield* process(sourceFile, node, /* @__PURE__ */ new Map([[ts.idText(identifier), type]]), isExported, false);
+    for (const statement of ctx.schemaStatements) {
+      changeTracker.insertNodeAt(sourceFile, node.pos, statement, { prefix: "\n", suffix: "\n" });
+    }
+  }
+);
+
+// src/codegens/typeToSchema.ts
+var typeToSchema = createCodegen({
+  name: "typeToSchema",
+  apply: fn("typeToSchema.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
+    const program = yield* service(TypeScriptProgram);
+    const inThisFile = yield* getCodegensForSourceFile([typeToSchema], sourceFile);
+    if (inThisFile.length > 1) {
+      return yield* fail3(
+        new CodegenNotApplicableError("the typeToSchema codegen can be used only once per file")
+      );
+    }
+    const parse3 = (node) => gen(function* () {
+      if (!ts.isTypeAliasDeclaration(node)) {
+        return yield* fail3(
+          new CodegenNotApplicableError(
+            "this codegen is applicable only to a type alias where each object member is a schema to generate. e.g. `type ToGenerate = { UserSchema: User, TodoSchema: Todo}`"
+          )
+        );
+      }
+      const type = typeChecker.getTypeAtLocation(node.name);
+      if (!type) {
+        return yield* fail3(
+          new CodegenNotApplicableError(
+            "error getting the type to process"
+          )
+        );
+      }
+      const nameToType = /* @__PURE__ */ new Map();
+      const typeProperties = typeChecker.getPropertiesOfType(type);
+      for (const symProp of typeProperties) {
+        const symName = ts.symbolName(symProp);
+        const propType = typeChecker.getTypeOfSymbolAtLocation(symProp, node);
+        if (propType) nameToType.set(symName, propType);
+      }
+      const hash2 = pipe(
+        fromIterable(nameToType),
+        map4(([name, type2]) => {
+          const typeString = typeChecker.typeToString(
+            type2,
+            node,
+            ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseStructuralFallback
+          );
+          return name + ": " + typeString;
+        }),
+        join("\n"),
+        cyrb53
+      );
+      return {
+        hash: hash2,
+        nameToType
+      };
+    });
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) {
+      return yield* fail3(new CodegenNotApplicableError("no node and comment range affected"));
+    }
+    return yield* pipe(
+      parse3(nodeAndCommentRange.node),
+      map8(
+        (_) => ({
+          hash: _.hash,
+          description: "Generate Schemas from types",
+          apply: pipe(
+            gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const ctx = yield* process(
+                sourceFile,
+                nodeAndCommentRange.node,
+                _.nameToType,
+                true,
+                true
+              );
+              const pos = sourceFile.end;
+              for (const range of ctx.rangesToDelete) {
+                changeTracker.deleteRange(sourceFile, range);
+              }
+              for (const statement of ctx.schemaStatements) {
+                changeTracker.insertNodeAt(sourceFile, pos, statement, { prefix: "\n", suffix: "\n" });
+              }
+            }),
+            provideService(TypeScriptApi, ts),
+            provideService(TypeScriptUtils, tsUtils),
+            provideService(TypeCheckerApi, typeChecker),
+            provideService(TypeCheckerUtils, typeCheckerUtils),
+            provideService(TypeParser, typeParser),
+            provideService(TypeScriptProgram, program)
+          )
+        })
+      )
+    );
+  })
+});
+
 // src/codegens.ts
-var codegens = [accessors, annotate];
+var codegens = [accessors, annotate, typeToSchema];
 
 // src/completions/effectCodegensComment.ts
 var effectCodegensComment = createCompletion({
@@ -16510,6 +17173,38 @@ var removeUnnecessaryEffectGen = createRefactor({
   })
 });
 
+// src/refactors/structuralTypeToSchema.ts
+var structuralTypeToSchema = createRefactor({
+  name: "structuralTypeToSchema",
+  description: "Refactor to Schema (Structural)",
+  apply: fn("structuralTypeToSchema.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
+    const program = yield* service(TypeScriptProgram);
+    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    if (isNone2(maybeNode)) {
+      return yield* fail3(new RefactorNotApplicableError());
+    }
+    const { identifier, isExported, node, type } = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.structuralTypeToSchema",
+      description: "Refactor to Schema (Recursive Structural)",
+      apply: pipe(
+        applyAtNode(sourceFile, node, identifier, type, isExported),
+        provideService(TypeCheckerApi, typeChecker),
+        provideService(TypeScriptUtils, tsUtils),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerUtils, typeCheckerUtils),
+        provideService(TypeParser, typeParser),
+        provideService(TypeScriptProgram, program)
+      )
+    };
+  })
+});
+
 // src/refactors/toggleLazyConst.ts
 var toggleLazyConst = createRefactor({
   name: "toggleLazyConst",
@@ -17161,7 +17856,7 @@ var createExportSchemaClassDeclaration = fn("SchemaGen.createExportSchemaClassDe
     );
   }
 );
-var process = fn("SchemaGen.process")(
+var process2 = fn("SchemaGen.process")(
   function* (sourceFile, node, preferClass) {
     const ctx = yield* makeSchemaGenContext(sourceFile);
     const ts = yield* service(TypeScriptApi);
@@ -17171,7 +17866,7 @@ var process = fn("SchemaGen.process")(
     );
   }
 );
-var findNodeToProcess = fn("SchemaGen.findNodeToProcess")(
+var findNodeToProcess2 = fn("SchemaGen.findNodeToProcess")(
   function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
@@ -17184,12 +17879,12 @@ var findNodeToProcess = fn("SchemaGen.findNodeToProcess")(
     );
   }
 );
-var applyAtNode = fn("SchemaGen.applyAtNode")(
+var applyAtNode2 = fn("SchemaGen.applyAtNode")(
   function* (sourceFile, node, preferClass) {
     const ts = yield* service(TypeScriptApi);
     const changeTracker = yield* service(ChangeTracker);
     const newNode = yield* pipe(
-      process(sourceFile, node, preferClass),
+      process2(sourceFile, node, preferClass),
       orElse2(
         (error) => succeed(ts.addSyntheticLeadingComment(
           ts.factory.createIdentifier(""),
@@ -17214,14 +17909,14 @@ var typeToEffectSchema = createRefactor({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    const maybeNode = yield* findNodeToProcess2(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.typeToEffectSchema",
       description: "Refactor to Schema",
       apply: pipe(
-        applyAtNode(sourceFile, node, false),
+        applyAtNode2(sourceFile, node, false),
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts),
@@ -17240,14 +17935,14 @@ var typeToEffectSchemaClass = createRefactor({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    const maybeNode = yield* findNodeToProcess2(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.typeToEffectSchemaClass",
       description: "Refactor to Schema.Class",
       apply: pipe(
-        applyAtNode(sourceFile, node, true),
+        applyAtNode2(sourceFile, node, true),
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
         provideService(TypeScriptApi, ts),
@@ -17338,6 +18033,7 @@ var refactors = [
   functionToArrow,
   typeToEffectSchema,
   typeToEffectSchemaClass,
+  structuralTypeToSchema,
   makeSchemaOpaque,
   makeSchemaOpaqueWithNs,
   pipeableToDatafirst,