@golemcloud/golem-ts-typegen 1.0.0-dev.4 → 1.0.0-dev.6

package/dist/index.js

@@ -1,830 +0,0 @@
-// Copyright 2024-2026 Golem Cloud
-//
-// Licensed under the Golem Source License v1.1 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://license.golem.cloud/LICENSE
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Node as TsMorphNode, Scope, SyntaxKind, ts, } from 'ts-morph';
-import { buildJSONFromType, Node, Symbol, TypeMetadata, } from '@golemcloud/golem-ts-types-core';
-import * as fs from 'node:fs';
-import path from 'path';
-export function getTypeFromTsMorph(tsMorphType, isOptional, sourceTypeNode) {
-    try {
-        return getTypeFromTsMorphInternal(tsMorphType, isOptional, new Set(), sourceTypeNode);
-    }
-    catch (e) {
-        if (e instanceof Error) {
-            let error = e.message;
-            if (e.stack) {
-                error = error + '\n\n' + e.stack;
-            }
-            return {
-                kind: 'unresolved-type',
-                name: undefined,
-                owner: undefined,
-                optional: isOptional,
-                text: tsMorphType.getText(),
-                error: error,
-            };
-        }
-        else {
-            throw e;
-        }
-    }
-}
-function getTypeFromTsMorphInternal(tsMorphType, isOptional, visitedTypes, sourceTypeNode) {
-    const type = unwrapAlias(tsMorphType);
-    const rawName = getRawTypeName(type);
-    const aliasName = getAliasTypeName(tsMorphType) ?? getAliasTypeName(type);
-    const owner = getTypeOwner(tsMorphType, sourceTypeNode) ?? getTypeOwner(type);
-    if (visitedTypes.has(tsMorphType)) {
-        return {
-            kind: 'others',
-            name: rawName ?? aliasName ?? type.getText(),
-            owner,
-            optional: isOptional,
-            recursive: true,
-        };
-    }
-    visitedTypes.add(tsMorphType);
-    switch (rawName) {
-        case 'Object':
-            return {
-                kind: 'others',
-                name: rawName,
-                owner,
-                optional: isOptional,
-                recursive: false,
-            };
-        case 'Float64Array':
-            return {
-                kind: 'array',
-                name: 'Float64Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Float32Array':
-            return {
-                kind: 'array',
-                name: 'Float32Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Int8Array':
-            return {
-                kind: 'array',
-                name: 'Int8Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Uint8Array':
-            return {
-                kind: 'array',
-                name: 'Uint8Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Int16Array':
-            return {
-                kind: 'array',
-                name: 'Int16Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Uint16Array':
-            return {
-                kind: 'array',
-                name: 'Uint16Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Int32Array':
-            return {
-                kind: 'array',
-                name: 'Int32Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'Uint32Array':
-            return {
-                kind: 'array',
-                name: 'Uint32Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'BigInt64Array':
-            return {
-                kind: 'array',
-                name: 'BigInt64Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-        case 'BigUint64Array':
-            return {
-                kind: 'array',
-                name: 'BigUint64Array',
-                owner,
-                element: {
-                    kind: 'number',
-                    owner: undefined,
-                    optional: false,
-                },
-                optional: isOptional,
-            };
-    }
-    // sdk config type
-    // because config type detection is unreliable currently, fall through to other detection if the node is malformed.
-    // Once we can reliably detect the node using symbols, we should surface an error to users here that they are using
-    // config in an unsupported way.
-    const sdkConfigType = getSdkConfigTypeFromTsMorph(type, rawName, aliasName, isOptional);
-    // eslint-disable-next-line eqeqeq
-    if (sdkConfigType != null)
-        return sdkConfigType;
-    // sdk quota-token type — detected by name; TODO switch to symbol-based matching
-    const sdkQuotaTokenType = getSdkQuotaTokenTypeFromTsMorph(rawName, aliasName, isOptional);
-    // eslint-disable-next-line eqeqeq
-    if (sdkQuotaTokenType != null)
-        return sdkQuotaTokenType;
-    // These will handle record types. However, record type is devoid
-    // of details, and hence we don't support record type at the SDK level
-    if (type.isObject() && type.getProperties().length === 0) {
-        const name = rawName ?? aliasName ?? type.getText();
-        return {
-            kind: 'others',
-            name: name,
-            owner,
-            optional: isOptional,
-            recursive: false,
-        };
-    }
-    if (rawName === 'Promise' && type.getTypeArguments().length === 1) {
-        const inner = type.getTypeArguments()[0];
-        const promiseType = getTypeFromTsMorphInternal(inner, false, visitedTypes);
-        return {
-            kind: 'promise',
-            name: aliasName,
-            owner,
-            element: promiseType,
-            optional: isOptional,
-        };
-    }
-    if (rawName === 'Map' && type.getTypeArguments().length === 2) {
-        const [keyT, valT] = type.getTypeArguments();
-        const key = getTypeFromTsMorphInternal(keyT, false, new Set(visitedTypes));
-        const value = getTypeFromTsMorphInternal(valT, false, new Set(visitedTypes));
-        return {
-            kind: 'map',
-            name: aliasName,
-            owner,
-            key: key,
-            value: value,
-            optional: isOptional,
-        };
-    }
-    if (type.isVoid()) {
-        return { kind: 'void', name: 'void', owner, optional: isOptional };
-    }
-    if (type.isBoolean()) {
-        return { kind: 'boolean', owner, optional: isOptional };
-    }
-    if (type.isLiteral()) {
-        const literalValue = type.getLiteralValue() ?? type.getText();
-        return {
-            kind: 'literal',
-            name: aliasName,
-            owner,
-            literalValue: literalValue.toString(),
-            optional: isOptional,
-        };
-    }
-    if (type.isTuple()) {
-        const tupleElems = type
-            .getTupleElements()
-            .map((el) => getTypeFromTsMorphInternal(el, false, new Set(visitedTypes)));
-        return {
-            kind: 'tuple',
-            name: aliasName,
-            owner,
-            elements: tupleElems,
-            optional: isOptional,
-        };
-    }
-    if (type.isArray()) {
-        const elementType = type.getArrayElementType();
-        let resolvedElementType;
-        if (elementType?.isTypeParameter()) {
-            resolvedElementType = tsMorphType.getAliasTypeArguments()[0];
-        }
-        else {
-            resolvedElementType = elementType;
-        }
-        if (!resolvedElementType) {
-            throw new Error('Array type without element type');
-        }
-        const element = getTypeFromTsMorphInternal(resolvedElementType, false, visitedTypes);
-        return {
-            kind: 'array',
-            name: aliasName,
-            owner,
-            element,
-            optional: isOptional,
-        };
-    }
-    if (type.isUnion()) {
-        const argsInternal = tsMorphType.getAliasTypeArguments();
-        const aliased = getAliasTypeArgumentsSafe(tsMorphType);
-        const unionTypes = getSourceOrderedUnionTypes(type, sourceTypeNode, visitedTypes) ??
-            getCanonicalFallbackUnionTypes(type.getUnionTypes(), visitedTypes);
-        const [aliasRawName, aliasedTypeArgs] = aliased;
-        if (argsInternal.length > 0 || !aliasRawName) {
-            const args = argsInternal.map((arg) => getTypeFromTsMorph(arg, false));
-            return {
-                kind: 'union',
-                name: aliasName,
-                owner,
-                unionTypes,
-                optional: isOptional,
-                typeParams: args,
-                originalTypeName: undefined,
-            };
-        }
-        const aliasedArgs = aliasedTypeArgs.map((arg) => getTypeFromTsMorph(arg, false));
-        return {
-            kind: 'union',
-            name: aliasName,
-            owner,
-            unionTypes,
-            optional: isOptional,
-            typeParams: aliasedArgs,
-            originalTypeName: aliasRawName,
-        };
-    }
-    if (type.isClass()) {
-        return {
-            kind: 'class',
-            name: aliasName ?? rawName,
-            owner,
-            properties: propertiesAsSymbols(type, visitedTypes),
-            optional: isOptional,
-        };
-    }
-    if (type.isInterface()) {
-        return {
-            kind: 'interface',
-            name: aliasName ?? rawName,
-            owner,
-            properties: propertiesAsSymbols(type, visitedTypes),
-            optional: isOptional,
-            typeParams: type.getAliasTypeArguments().map((arg) => getTypeFromTsMorph(arg, false)),
-        };
-    }
-    if (type.isObject()) {
-        const args = tsMorphType.getAliasTypeArguments().map((arg) => getTypeFromTsMorph(arg, false));
-        return {
-            kind: 'object',
-            name: aliasName,
-            owner,
-            properties: propertiesAsSymbols(type, visitedTypes),
-            typeParams: args,
-            optional: isOptional,
-        };
-    }
-    if (type.isNull()) {
-        return { kind: 'null', name: aliasName, owner, optional: isOptional };
-    }
-    if (type.isBigInt()) {
-        return { kind: 'bigint', name: aliasName, owner, optional: isOptional };
-    }
-    if (type.isUndefined()) {
-        return { kind: 'undefined', name: aliasName, owner, optional: isOptional };
-    }
-    if (type.isNumber()) {
-        return { kind: 'number', name: aliasName, owner, optional: isOptional };
-    }
-    if (type.isString()) {
-        return { kind: 'string', name: aliasName, owner, optional: isOptional };
-    }
-    if (type.getTypeArguments().length === 1) {
-        throw new Error(`Unhandled type with single type argument: ${type.getText()}`);
-    }
-    return {
-        kind: 'others',
-        name: aliasName ?? type.getText(),
-        owner,
-        optional: isOptional,
-        recursive: false,
-    };
-}
-// This is intentionally used as a deterministic fallback order for union members.
-// Source-order recovery (when AST nodes are available) overrides this fallback.
-function getCanonicalFallbackUnionTypes(unionTypes, visitedTypes) {
-    const withKeys = unionTypes.map((member, index) => {
-        const mapped = getTypeFromTsMorphInternal(member, false, new Set(visitedTypes));
-        return {
-            index,
-            mapped,
-            key: getCanonicalUnionSortKey(mapped),
-        };
-    });
-    withKeys.sort((a, b) => {
-        if (a.key < b.key)
-            return -1;
-        if (a.key > b.key)
-            return 1;
-        return a.index - b.index;
-    });
-    return withKeys.map(({ mapped }) => mapped);
-}
-function getSourceOrderedUnionTypes(unionType, sourceTypeNode, visitedTypes) {
-    const sourceUnionTypeNode = resolveUnionTypeNode(sourceTypeNode) ?? resolveUnionTypeNodeFromType(unionType);
-    if (!sourceUnionTypeNode)
-        return undefined;
-    return sourceUnionTypeNode
-        .getTypeNodes()
-        .map((member) => getTypeFromTsMorphInternal(member.getType(), false, new Set(visitedTypes), member));
-}
-function resolveUnionTypeNodeFromType(type) {
-    const aliasSymbol = type.getAliasSymbol();
-    if (!aliasSymbol)
-        return undefined;
-    for (const declaration of aliasSymbol.getDeclarations()) {
-        if (!TsMorphNode.isTypeAliasDeclaration(declaration))
-            continue;
-        const unionTypeNode = resolveUnionTypeNode(declaration.getTypeNode());
-        if (unionTypeNode)
-            return unionTypeNode;
-    }
-    return undefined;
-}
-function resolveUnionTypeNode(node) {
-    if (!node)
-        return undefined;
-    if (TsMorphNode.isUnionTypeNode(node)) {
-        return node;
-    }
-    if (TsMorphNode.isParenthesizedTypeNode(node)) {
-        return resolveUnionTypeNode(node.getTypeNode());
-    }
-    return undefined;
-}
-function getCanonicalUnionSortKey(type) {
-    const rank = getUnionTypeKindRank(type.kind).toString().padStart(2, '0');
-    return `${rank}:${JSON.stringify(buildJSONFromType(type))}`;
-}
-function getUnionTypeKindRank(kind) {
-    switch (kind) {
-        case 'undefined':
-            return 0;
-        case 'null':
-            return 1;
-        case 'void':
-            return 2;
-        case 'string':
-            return 3;
-        case 'number':
-            return 4;
-        case 'bigint':
-            return 5;
-        case 'boolean':
-            return 6;
-        case 'literal':
-            return 7;
-        case 'tuple':
-            return 8;
-        case 'array':
-            return 9;
-        case 'map':
-            return 10;
-        case 'object':
-            return 11;
-        case 'interface':
-            return 12;
-        case 'class':
-            return 13;
-        case 'promise':
-            return 14;
-        case 'union':
-            return 15;
-        case 'config':
-            return 16;
-        case 'quota-token':
-            return 16;
-        case 'alias':
-            return 17;
-        case 'others':
-            return 18;
-        case 'unresolved-type':
-            return 19;
-    }
-}
-function getSdkConfigTypeFromTsMorph(type, rawName, aliasName, isOptional) {
-    if (rawName !== 'Config')
-        return undefined;
-    if (type.getTypeArguments().length !== 1)
-        return undefined;
-    const rawInner = type.getTypeArguments()[0];
-    const innerType = unwrapAlias(rawInner);
-    const typeLiteral = resolveStrictTypeLiteralNode(innerType);
-    if (!typeLiteral)
-        return undefined;
-    const properties = extractConfigPropertiesFromTypeLiteral(typeLiteral, []);
-    if (!properties)
-        return undefined;
-    return {
-        kind: 'config',
-        name: aliasName,
-        owner: getTypeOwner(type),
-        optional: isOptional,
-        properties,
-    };
-}
-function getSdkQuotaTokenTypeFromTsMorph(rawName, aliasName, isOptional) {
-    // Detected by name, same as Config above — TODO: switch to symbol-based matching
-    if (rawName !== 'QuotaToken')
-        return undefined;
-    return { kind: 'quota-token', name: aliasName, optional: isOptional };
-}
-// TypeLiteral in TS AST is `type A = {}`. Union types, etc. get other node types
-function resolveStrictTypeLiteralNode(type) {
-    const symbol = type.getSymbol();
-    if (!symbol)
-        return undefined;
-    const typeLiteralDecl = symbol.getDeclarations().find(TsMorphNode.isTypeLiteral);
-    return typeLiteralDecl;
-}
-function extractConfigPropertiesFromTypeLiteral(node, path) {
-    const members = node.getMembers();
-    if (!members.every(TsMorphNode.isPropertySignature)) {
-        return undefined;
-    }
-    const results = [];
-    for (const member of members) {
-        const name = member.getName();
-        const nextPath = [...path, name];
-        const propType = unwrapAlias(member.getType());
-        // 1. secret wrapper
-        // TODO: switch to nominal matching using symbols instead of string
-        if (propType.getSymbol()?.getName() === 'Secret' && propType.getTypeArguments().length === 1) {
-            results.push({
-                path: nextPath,
-                secret: true,
-                type: getTypeFromTsMorph(propType.getTypeArguments()[0], member.hasQuestionToken(), member.getTypeNode()),
-            });
-            continue;
-        }
-        // 2. nested type literal
-        const nestedTypeLiteral = resolveStrictTypeLiteralNode(propType);
-        // eslint-disable-next-line eqeqeq
-        if (nestedTypeLiteral != null) {
-            const nested = extractConfigPropertiesFromTypeLiteral(nestedTypeLiteral, nextPath);
-            // eslint-disable-next-line eqeqeq
-            if (nested == null)
-                return undefined;
-            results.push(...nested);
-            continue;
-        }
-        // 3. leaf node
-        results.push({
-            path: nextPath,
-            secret: false,
-            type: getTypeFromTsMorph(propType, member.hasQuestionToken(), member.getTypeNode()),
-        });
-    }
-    return results;
-}
-function getAliasTypeArgumentsSafe(type) {
-    const aliasSymbol = type.getAliasSymbol();
-    if (!aliasSymbol)
-        return [undefined, []];
-    const decl = aliasSymbol.getDeclarations()[0];
-    if (!decl || !decl.isKind(ts.SyntaxKind.TypeAliasDeclaration))
-        return [undefined, []];
-    const typeNode = decl.getTypeNodeOrThrow();
-    const typeRef = typeNode.asKind(ts.SyntaxKind.TypeReference);
-    if (!typeRef)
-        return [undefined, []];
-    return [typeRef.getTypeName().getText(), typeRef.getTypeArguments().map((arg) => arg.getType())];
-}
-export function getRawTypeName(type) {
-    const rawName = type.getSymbol()?.getName();
-    if (!rawName || rawName === '__type') {
-        const alias = type.getAliasSymbol()?.getName();
-        if (!alias || alias === '__type') {
-            return type.getText();
-        }
-        return alias;
-    }
-    return rawName;
-}
-export function getAliasTypeName(type) {
-    const alias = type.getAliasSymbol()?.getName();
-    if (!alias || alias === '__type') {
-        return undefined;
-    }
-    return alias;
-}
-export function getTypeOwner(type, sourceTypeNode) {
-    return (getOwnerFromSourceTypeNode(sourceTypeNode) ??
-        getOwnerFromDeclarations(type.getAliasSymbol()?.getDeclarations()) ??
-        getOwnerFromDeclarations(type.getSymbol()?.getDeclarations()));
-}
-function getOwnerFromSourceTypeNode(node) {
-    if (!node)
-        return undefined;
-    if (TsMorphNode.isTypeReference(node)) {
-        const typeNameSymbol = node.getTypeName().getSymbol();
-        const fromTypeName = getOwnerFromDeclarations(typeNameSymbol?.getDeclarations());
-        if (fromTypeName)
-            return fromTypeName;
-        return getOwnerFromDeclarations(node.getType().getAliasSymbol()?.getDeclarations());
-    }
-    return undefined;
-}
-function getOwnerFromDeclarations(declarations) {
-    if (!declarations || declarations.length === 0)
-        return undefined;
-    for (const declaration of declarations) {
-        const importDeclaration = declaration.getFirstAncestorByKind(SyntaxKind.ImportDeclaration);
-        if (importDeclaration) {
-            return importDeclaration.getModuleSpecifierValue();
-        }
-        const moduleDeclaration = declaration.getFirstAncestorByKind(SyntaxKind.ModuleDeclaration);
-        if (moduleDeclaration) {
-            const moduleName = moduleDeclaration.getName();
-            return moduleName.replace(/^['"]|['"]$/g, '');
-        }
-    }
-    return undefined;
-}
-export function unwrapAlias(type) {
-    let current = type;
-    const visited = new Set();
-    while (true) {
-        const aliasSymbol = current.getAliasSymbol();
-        if (!aliasSymbol || visited.has(current))
-            break;
-        visited.add(current);
-        const decl = aliasSymbol.getDeclarations()[0];
-        if (!decl)
-            break;
-        const realType = decl.getType();
-        if (realType === current)
-            break;
-        current = realType;
-    }
-    return current;
-}
-export function generateClassMetadata(classMetadataGenConfig) {
-    updateMetadataFromSourceFiles(classMetadataGenConfig);
-    return saveAndClearInMemoryMetadata();
-}
-export function updateMetadataFromSourceFiles(classMetadataGenConfig) {
-    for (const sourceFile of classMetadataGenConfig.sourceFiles) {
-        const classes = sourceFile.getClasses();
-        for (const classDecl of classes) {
-            if (classMetadataGenConfig.classDecorators.length > 0) {
-                const hasAnyConfiguredDecorator = classDecl
-                    .getDecorators()
-                    .some((d) => classMetadataGenConfig.classDecorators.includes(d.getName()));
-                if (!hasAnyConfiguredDecorator) {
-                    continue;
-                }
-            }
-            const className = classDecl.getName();
-            if (!className)
-                continue;
-            const publicConstructors = classMetadataGenConfig.includeOnlyPublicScope
-                ? classDecl.getConstructors().filter((ctor) => ctor.getScope() === Scope.Public)
-                : classDecl.getConstructors();
-            const constructorArgs = publicConstructors.length === 0
-                ? []
-                : publicConstructors[0].getParameters().map((p) => ({
-                    name: p.getName(),
-                    type: getTypeFromTsMorph(p.getType(), p.isOptional(), p.getTypeNode()),
-                }));
-            const methods = new Map();
-            const publicMethods = classMetadataGenConfig.includeOnlyPublicScope
-                ? classDecl.getMethods().filter((m) => m.getScope() === Scope.Public)
-                : classDecl.getMethods();
-            for (const method of publicMethods) {
-                if (classMetadataGenConfig.excludeOverriddenMethods &&
-                    (method.hasOverrideKeyword() || isOverriddenMethod(method))) {
-                    continue;
-                }
-                const methodParams = new Map(method.getParameters().map((p) => {
-                    return [p.getName(), getTypeFromTsMorph(p.getType(), p.isOptional(), p.getTypeNode())];
-                }));
-                const returnType = getTypeFromTsMorph(method.getReturnType(), false, method.getReturnTypeNode());
-                methods.set(method.getName(), { methodParams, returnType });
-            }
-            const isScopeAllowed = (decl) => !classMetadataGenConfig.includeOnlyPublicScope || decl.getScope() === Scope.Public;
-            const publicArrows = classDecl
-                .getProperties()
-                .filter((p) => isScopeAllowed(p) &&
-                p.getType().getCallSignatures().length > 0 &&
-                p.hasInitializer() &&
-                (p.getInitializerIfKind(SyntaxKind.ArrowFunction) ||
-                    p.getInitializerIfKind(SyntaxKind.FunctionExpression)));
-            for (const publicArrow of publicArrows) {
-                if (classMetadataGenConfig.excludeOverriddenMethods &&
-                    (publicArrow.hasOverrideKeyword() || isOverriddenProperty(publicArrow))) {
-                    continue;
-                }
-                const arrowType = publicArrow.getType();
-                const callSignature = arrowType.getCallSignatures()[0];
-                if (!callSignature)
-                    continue;
-                const methodParams = new Map(callSignature.getParameters().map((p) => {
-                    const decl = p.getDeclarations()[0];
-                    if (!decl) {
-                        throw new Error(`No declaration found for parameter ${p.getName()} in arrow method ${publicArrow.getName()} of class ${className}`);
-                    }
-                    const paramType = p.getTypeAtLocation(decl);
-                    const isOptional = TsMorphNode.isParameterDeclaration(decl) ? decl.isOptional() : false;
-                    const sourceTypeNode = TsMorphNode.isParameterDeclaration(decl)
-                        ? decl.getTypeNode()
-                        : undefined;
-                    return [p.getName(), getTypeFromTsMorph(paramType, isOptional, sourceTypeNode)];
-                }));
-                const returnType = getTypeFromTsMorph(callSignature.getReturnType(), false);
-                methods.set(publicArrow.getName(), { methodParams, returnType });
-            }
-            TypeMetadata.update(className, constructorArgs, methods);
-        }
-    }
-}
-function isOverriddenMethod(method) {
-    const classDecl = method.getFirstAncestorByKind(SyntaxKind.ClassDeclaration);
-    if (!classDecl)
-        return false;
-    let currentBase = classDecl.getBaseClass();
-    const methodName = method.getName();
-    while (currentBase) {
-        const baseMethod = currentBase.getInstanceMethod(methodName);
-        if (baseMethod)
-            return true;
-        currentBase = currentBase.getBaseClass();
-    }
-    return false;
-}
-function isOverriddenProperty(prop) {
-    const classDecl = prop.getFirstAncestorByKind(SyntaxKind.ClassDeclaration);
-    if (!classDecl)
-        return false;
-    let currentBase = classDecl.getBaseClass();
-    const propName = prop.getName();
-    while (currentBase) {
-        const baseProp = currentBase.getInstanceProperty(propName);
-        if (baseProp)
-            return true;
-        // See if overriding a method with an arrow
-        const baseMethod = currentBase.getInstanceMethod(propName);
-        if (baseMethod)
-            return true;
-        currentBase = currentBase.getBaseClass();
-    }
-    return false;
-}
-const METADATA_DIR = '.metadata';
-const METADATA_TS_FILE = 'generated-types.ts';
-const METADATA_JSON_FILE = 'generated-types.json';
-export function saveAndClearInMemoryMetadata() {
-    if (!fs.existsSync(METADATA_DIR)) {
-        fs.mkdirSync(METADATA_DIR);
-    }
-    const json = {};
-    for (const [className, meta] of TypeMetadata.getAll().entries()) {
-        const constructorArgsJSON = meta.constructorArgs.map((arg) => ({
-            name: arg.name,
-            type: buildJSONFromType(arg.type),
-        }));
-        const methodsObj = {};
-        for (const [methodName, { methodParams, returnType }] of meta.methods) {
-            const paramsJSON = {};
-            for (const [paramName, paramType] of methodParams.entries()) {
-                paramsJSON[paramName] = buildJSONFromType(paramType);
-            }
-            methodsObj[methodName] = {
-                methodParams: paramsJSON,
-                returnType: buildJSONFromType(returnType),
-            };
-        }
-        json[className] = {
-            constructorArgs: constructorArgsJSON,
-            methods: methodsObj,
-        };
-    }
-    const tsFilePath = path.join(METADATA_DIR, METADATA_TS_FILE);
-    const jsonFilePath = path.join(METADATA_DIR, METADATA_JSON_FILE);
-    const tsContent = `export const Metadata = ${JSON.stringify(json, null, 2)};`;
-    const jsonContent = JSON.stringify(json, null, 2);
-    fs.writeFileSync(tsFilePath, tsContent, 'utf-8');
-    fs.writeFileSync(jsonFilePath, jsonContent, 'utf-8');
-    TypeMetadata.clearAll();
-    return tsFilePath;
-}
-export function lazyLoadTypeMetadata() {
-    if (TypeMetadata.getAll().size === 0) {
-        loadTypeMetadataFromJsonFile();
-    }
-}
-export function loadTypeMetadataFromJsonFile() {
-    TypeMetadata.clearMetadata();
-    const filePath = path.join(METADATA_DIR, METADATA_JSON_FILE);
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`${filePath} does not exist`);
-    }
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const json = JSON.parse(raw);
-    TypeMetadata.loadFromJson(json);
-}
-function propertiesAsSymbols(type, visitedTypes) {
-    return type.getProperties().map((prop) => {
-        const firstDeclaration = prop.getDeclarations()[0];
-        // NOTE: falling back to firstDeclaration if no value declaration found,
-        //       to support runtime generated or manipulated types
-        const type = prop.getTypeAtLocation(getValueDeclaration(prop) ?? firstDeclaration);
-        const sourceTypeNode = TsMorphNode.isPropertySignature(firstDeclaration) ||
-            TsMorphNode.isPropertyDeclaration(firstDeclaration)
-            ? firstDeclaration.getTypeNode()
-            : undefined;
-        const tsType = getTypeFromTsMorphInternal(type, false, new Set(visitedTypes), sourceTypeNode);
-        const propName = prop.getName();
-        if ((TsMorphNode.isPropertySignature(firstDeclaration) ||
-            TsMorphNode.isPropertyDeclaration(firstDeclaration)) &&
-            firstDeclaration.hasQuestionToken()) {
-            return new Symbol({
-                name: propName,
-                declarations: [new Node('PropertyDeclaration', true)],
-                typeAtLocation: tsType,
-            });
-        }
-        else {
-            return new Symbol({
-                name: propName,
-                declarations: [new Node('PropertyDeclaration', false)],
-                typeAtLocation: tsType,
-            });
-        }
-    });
-}
-function getValueDeclaration(symbol) {
-    try {
-        return symbol.getValueDeclarationOrThrow();
-    }
-    catch {
-        return undefined;
-    }
-}