@effect/language-service 0.61.0 → 0.62.1

package/effect-lsp-patch-utils.js

@@ -766,6 +766,10 @@ var isEmptyArray = (self) => self.length === 0;
 var isEmptyReadonlyArray = isEmptyArray;
 var isNonEmptyReadonlyArray = isNonEmptyArray;
 var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
+var get = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  return isOutOfBounds(i, self) ? none2() : some2(self[i]);
+});
 var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
   if (isOutOfBounds(i, self)) {
@@ -773,6 +777,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
   }
   return self[i];
 });
+var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
 var reverse = (self) => Array.from(self).reverse();
@@ -836,6 +841,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));
 
 // src/core/Nano.ts
 var NanoTag = class {
@@ -2183,6 +2189,8 @@ var nanoLayer2 = (fa) => pipe(
   )
 );
 function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
+  const readonlyArraySymbol = typeChecker.resolveName("ReadonlyArray", void 0, ts.SymbolFlags.Type, false);
+  const globalReadonlyArrayType = readonlyArraySymbol ? typeChecker.getDeclaredTypeOfSymbol(readonlyArraySymbol) : void 0;
   function isUnion(type) {
     return !!(type.flags & ts.TypeFlags.Union);
   }
@@ -2192,6 +2200,12 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   function isThisTypeParameter(type) {
     return !!(type.flags & ts.TypeFlags.TypeParameter && type.isThisType);
   }
+  function isReadonlyArrayType(type) {
+    return type && "target" in type && type.target === globalReadonlyArrayType;
+  }
+  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)) {
@@ -2496,6 +2510,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   }
   return {
     isUnion,
+    isReadonlyArrayType,
+    isMissingIntrinsicType,
     getTypeParameterAtPosition,
     getMissingTypeEntriesInTargetType,
     unrollUnionMembers,
@@ -5667,8 +5683,664 @@ 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* fail(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* fail(
+      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, typeCheckerUtils } = yield* service(StructuralSchemaGenContext);
+    const typeArgs = typeChecker.getTypeArguments(type);
+    if (typeArgs.length === 0) {
+      return yield* fail(new UnsupportedTypeError(type, "Array type has no type arguments"));
+    }
+    const elementSchema = yield* processType(typeArgs[0], context);
+    const expr = createApiCall("Array", [elementSchema]);
+    if (typeCheckerUtils.isReadonlyArrayType(type)) return [expr, false];
+    return [createApiCall("mutable", [expr]), 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),
+      map3((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
+              ))
+            ),
+            map4((_) => ({ 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),
+        map3(([_, 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* fail(
+        new CodegenNotApplicableError("the typeToSchema codegen can be used only once per file")
+      );
+    }
+    const parse3 = (node) => gen(function* () {
+      if (!ts.isTypeAliasDeclaration(node)) {
+        return yield* fail(
+          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* fail(
+          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),
+        map3(([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* fail(new CodegenNotApplicableError("no node and comment range affected"));
+    }
+    return yield* pipe(
+      parse3(nodeAndCommentRange.node),
+      map4(
+        (_) => ({
+          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/diagnostics/outdatedEffectCodegen.ts
 var outdatedEffectCodegen = createDiagnostic({