@typra/emitter 0.2.0

package/dist/src/ir/ast.js

@@ -0,0 +1,589 @@
+import { getDoc, getTypeName, isTemplateInstance, getNamespaceFullName, getDiscriminator, } from "@typespec/compiler";
+import { getStateScalar, getStateValue } from "../decorators.js";
+import { StateKeys } from "../lib.js";
+const getModelType = (model, rootNamespace, rootAlias) => {
+    let namespace = model.namespace ? getNamespaceFullName(model.namespace) : rootNamespace || "";
+    if (rootNamespace.includes('.'))
+        namespace = rootNamespace;
+    else {
+        const parts = namespace.split(".");
+        parts[0] = rootNamespace;
+        namespace = parts.join(".");
+    }
+    const name = getTypeName(model, {
+        nameOnly: true,
+        printable: true,
+    });
+    if (rootAlias) {
+        const rootName = rootNamespace.split(".").at(-1) || rootNamespace;
+        return {
+            namespace: namespace,
+            name: name.replace(rootName, rootAlias)
+        };
+    }
+    return {
+        namespace: namespace,
+        name: name
+    };
+};
+/**
+ * Walk up the AST parent chain from `node` to find the enclosing
+ * TypeSpecScriptNode (identified by presence of `file.path`), which
+ * carries the source file path. Returns `""` if not found.
+ *
+ * We use `any` because TypeSpec does not export `Node`, `SyntaxKind`,
+ * or `TypeSpecScriptNode` from its public API surface.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getNodeFilePath(node) {
+    let current = node;
+    while (current) {
+        if (current?.file?.path) {
+            return current.file.path;
+        }
+        current = current.parent;
+    }
+    return "";
+}
+/**
+ * Extract the semantic group (subfolder) name from a TypeSpec source file path.
+ *
+ * The TSP model files are organised under `schema/model/{group}/{file}.tsp`.
+ * This function finds the first `/model/` segment and returns the folder name
+ * immediately after it (the group), or `""` if the file is at the model root.
+ *
+ * Examples:
+ *   ".../schema/model/connection/connection.tsp"  → "connection"
+ *   ".../schema/model/model/model.tsp"            → "model"
+ *   ".../schema/model/main.tsp"                   → ""
+ */
+function extractGroup(sourcePath) {
+    const normalized = sourcePath.replace(/\\/g, "/");
+    const idx = normalized.indexOf("/model/");
+    if (idx < 0)
+        return "";
+    const afterModel = normalized.slice(idx + "/model/".length);
+    const slash = afterModel.indexOf("/");
+    return slash >= 0 ? afterModel.slice(0, slash) : "";
+}
+export class TypeNode {
+    model;
+    typeName = {
+        namespace: "",
+        name: ""
+    };
+    description;
+    base = null;
+    childTypes = [];
+    coercions = [];
+    properties = [];
+    isAbstract = false;
+    isProtocol = false;
+    discriminator = undefined;
+    factories = [];
+    methods = [];
+    /** Semantic group derived from the TSP source subfolder (e.g. "connection", "tools"). */
+    group = "";
+    constructor(model, description) {
+        this.model = model;
+        this.model = model;
+        this.description = description;
+    }
+    retrievePolymorphicTypes() {
+        let instances = [];
+        if (this.discriminator && this.childTypes.length > 0) {
+            instances = this.childTypes.map(child => ({
+                discriminator: this.discriminator,
+                value: child.properties.find(p => p.name === this.discriminator)?.defaultValue || "*",
+                instance: child,
+            }));
+            if (!this.isAbstract) {
+                instances = [...instances, { discriminator: this.discriminator, value: "*", instance: this }];
+            }
+            const filteredInstances = instances.filter(instance => instance.value !== "*");
+            const defaultInstance = instances.filter(i => i.value === "*")[0];
+            return {
+                types: filteredInstances,
+                default: defaultInstance,
+            };
+        }
+        return undefined;
+    }
+    ;
+    getSanitizedObject() {
+        return {
+            typeName: this.typeName,
+            description: this.description,
+            base: this.base || {},
+            isAbstract: this.isAbstract,
+            isProtocol: this.isProtocol,
+            discriminator: this.discriminator,
+            coercions: this.coercions,
+            factories: this.factories,
+            methods: this.methods,
+            childTypes: this.childTypes.map(ct => ct.getSanitizedObject()),
+            properties: this.properties.map(prop => prop.getSanitizedObject()),
+        };
+    }
+}
+export class PropertyNode {
+    name;
+    typeName = {
+        namespace: "",
+        name: ""
+    };
+    description;
+    samples = [];
+    knownAs = [];
+    defaultFor = [];
+    isScalar = false;
+    isOptional = false;
+    isCollection = false;
+    isAny = false;
+    isDict = false;
+    defaultValue = null;
+    allowedValues = [];
+    /** Name of the string-literal union alias (e.g., "Role"), null if unnamed or not an enum. */
+    enumName = null;
+    /** True when the union includes a bare `string` variant (open enum — accepts any string). */
+    isOpenEnum = false;
+    property;
+    type = undefined;
+    constructor(property, description) {
+        this.name = property.name;
+        this.description = description;
+        this.property = property;
+    }
+    getSanitizedObject() {
+        return {
+            name: this.name,
+            typeName: this.typeName,
+            description: this.description,
+            samples: this.samples,
+            knownAs: this.knownAs,
+            defaultFor: this.defaultFor,
+            isScalar: this.isScalar,
+            isOptional: this.isOptional,
+            isCollection: this.isCollection,
+            isAny: this.isAny,
+            isDict: this.isDict,
+            defaultValue: this.defaultValue || "null",
+            allowedValues: this.allowedValues,
+            enumName: this.enumName,
+            isOpenEnum: this.isOpenEnum,
+            type: this.type ? this.type.getSanitizedObject() : undefined,
+        };
+    }
+}
+export const enumerateTypes = function* (node, visited = new Set()) {
+    for (const prop of node.properties) {
+        if (prop.type) {
+            // enumerate
+            for (const subNode of enumerateTypes(prop.type, visited)) {
+                if (!visited.has(`${subNode.typeName.namespace}.${subNode.typeName.name}`)) {
+                    yield subNode;
+                    visited.add(`${subNode.typeName.namespace}.${subNode.typeName.name}`);
+                }
+            }
+            for (const child of prop.type.childTypes) {
+                for (const subNode of enumerateTypes(child, visited)) {
+                    if (!visited.has(`${subNode.typeName.namespace}.${subNode.typeName.name}`)) {
+                        yield subNode;
+                        visited.add(`${subNode.typeName.namespace}.${subNode.typeName.name}`);
+                    }
+                }
+            }
+        }
+    }
+    if (!visited.has(`${node.typeName.namespace}.${node.typeName.name}`)) {
+        yield node;
+        for (const child of node.childTypes) {
+            for (const subNode of enumerateTypes(child, visited)) {
+                if (!visited.has(`${subNode.typeName.namespace}.${subNode.typeName.name}`)) {
+                    yield subNode;
+                    visited.add(`${subNode.typeName.namespace}.${subNode.typeName.name}`);
+                }
+            }
+        }
+        visited.add(`${node.typeName.namespace}.${node.typeName.name}`);
+    }
+};
+export const resolveModel = (program, model, visited = new Set(), rootNamespace, rootAlias) => {
+    const node = new TypeNode(model, getDoc(program, model) || "");
+    if (model.name === "Named") {
+        // Use Named<T> for actual model props, but innerModel for naming and docs
+        const innerModel = getTemplateModel(model);
+        if (!innerModel || innerModel.kind !== "Model") {
+            throw new Error(`Invalid Named<T> model: ${model.name}`);
+        }
+        node.typeName = getModelType(innerModel, rootNamespace, rootAlias);
+        node.childTypes = resolveModelChildren(program, innerModel, visited, rootNamespace, rootAlias);
+        node.description = getDoc(program, innerModel) || "";
+        node.isAbstract = getStateScalar(program, StateKeys.abstracts, innerModel) || false;
+        node.isProtocol = getStateScalar(program, StateKeys.protocols, innerModel) || false;
+        const discriminator = getDiscriminator(program, innerModel);
+        node.discriminator = discriminator ? discriminator.propertyName : undefined;
+        // coercion .ctor
+        node.coercions = getStateValue(program, StateKeys.coercions, innerModel);
+        // factory and method stubs
+        node.factories = getStateValue(program, StateKeys.factories, innerModel);
+        node.methods = getStateValue(program, StateKeys.methods, innerModel);
+        node.group = extractGroup(getNodeFilePath(innerModel.node));
+        visited.add(innerModel.name);
+    }
+    else {
+        node.typeName = getModelType(model, rootNamespace, rootAlias);
+        node.childTypes = resolveModelChildren(program, model, visited, rootNamespace, rootAlias);
+        node.isAbstract = getStateScalar(program, StateKeys.abstracts, model) || false;
+        node.isProtocol = getStateScalar(program, StateKeys.protocols, model) || false;
+        const discriminator = getDiscriminator(program, model);
+        node.discriminator = discriminator ? discriminator.propertyName : undefined;
+        // coercion .ctor
+        node.coercions = getStateValue(program, StateKeys.coercions, model);
+        // factory and method stubs
+        node.factories = getStateValue(program, StateKeys.factories, model);
+        node.methods = getStateValue(program, StateKeys.methods, model);
+        node.group = extractGroup(getNodeFilePath(model.node));
+        visited.add(model.name);
+    }
+    if (model.baseModel) {
+        node.base = getModelType(model.baseModel, rootNamespace, rootAlias);
+    }
+    // resolve properties if model
+    if (model.kind === "Model") {
+        const properties = [];
+        for (const [_, value] of model.properties) {
+            const prop = resolveProperty(program, value, visited, rootNamespace, rootAlias);
+            // samples
+            prop.samples = getStateValue(program, StateKeys.samples, value);
+            // wire mappings
+            prop.knownAs = getStateValue(program, StateKeys.knownAs, value);
+            prop.defaultFor = getStateValue(program, StateKeys.defaultFor, value);
+            properties.push(prop);
+        }
+        node.properties = properties;
+    }
+    return node;
+};
+export const resolveModelChildren = (program, model, visited, rootNamespace, rootAlias) => {
+    return model.derivedModels.filter(derived => !visited.has(derived.name)).flatMap(derived => {
+        return [resolveModel(program, derived, visited, rootNamespace, rootAlias), ...resolveModelChildren(program, derived, visited, rootNamespace, rootAlias)];
+    });
+};
+export const resolveProperty = (program, property, visited, rootNamespace, rootAlias) => {
+    switch (property.type.kind) {
+        case "Scalar":
+            return resolveScalarProperty(program, property, property.type);
+        case "Model":
+            return resolveModelProperty(program, property, property.type, visited, rootNamespace, rootAlias);
+        case "Union":
+            return resolveUnionProperty(program, property, property.type, visited, rootNamespace, rootAlias);
+        case "Intrinsic":
+            return resolveIntrinsicProperty(program, property, property.type, visited);
+        case "String":
+            // this is for default values in discriminated types
+            const prop = new PropertyNode(property, getDoc(program, property) || "");
+            prop.defaultValue = property.type.value;
+            prop.typeName = {
+                namespace: "",
+                name: "string"
+            };
+            prop.isScalar = true;
+            prop.isAny = false;
+            prop.isOptional = property.optional;
+            prop.isCollection = false;
+            return prop;
+        default:
+            program.reportDiagnostic({
+                code: "typra-emitter-unsupported-property-type",
+                message: `Unsupported property type: ${property.type.kind}`,
+                severity: "error",
+                target: property
+            });
+            return new PropertyNode(property, getDoc(program, property) || "");
+    }
+};
+export const resolveScalarProperty = (program, property, scalar) => {
+    const prop = new PropertyNode(property, getDoc(program, property) || "");
+    prop.typeName = {
+        namespace: "",
+        name: getTypeName(scalar, { nameOnly: true })
+    };
+    prop.isScalar = true;
+    prop.isAny = false;
+    prop.isOptional = property.optional;
+    prop.isCollection = false;
+    // defaults
+    if (property.defaultValue) {
+        // only handle these things
+        switch (property.defaultValue.valueKind) {
+            case "StringValue":
+                prop.defaultValue = property.defaultValue.value;
+                break;
+            case "BooleanValue":
+                prop.defaultValue = property.defaultValue.value;
+                break;
+            case "NumericValue":
+                prop.defaultValue = property.defaultValue.value.asNumber();
+                break;
+            default:
+                prop.defaultValue = "unspecified";
+                break;
+        }
+    }
+    return prop;
+};
+export const resolveIntrinsicProperty = (program, property, intrinsic, visited) => {
+    const prop = new PropertyNode(property, getDoc(program, property) || "");
+    prop.typeName = {
+        namespace: "",
+        name: getTypeName(intrinsic, { nameOnly: true })
+    };
+    prop.isScalar = true;
+    prop.isAny = true;
+    prop.isOptional = property.optional;
+    prop.isCollection = prop.typeName.name.includes("[") && prop.typeName.name.includes("]");
+    // defaults
+    if (property.defaultValue) {
+        // only handle these things
+        switch (property.defaultValue.valueKind) {
+            case "StringValue":
+                prop.defaultValue = property.defaultValue.value;
+                break;
+            case "BooleanValue":
+                prop.defaultValue = property.defaultValue.value;
+                break;
+            case "NumericValue":
+                prop.defaultValue = property.defaultValue.value.asNumber();
+                break;
+            default:
+                prop.defaultValue = null;
+                break;
+        }
+    }
+    return prop;
+};
+export const resolveModelProperty = (program, property, model, visited, rootNamespace, rootAlias) => {
+    const prop = new PropertyNode(property, getDoc(program, property) || "");
+    if (model.name === "Array") {
+        const innerModel = getTemplateModel(model);
+        if (innerModel) {
+            // Use innerModel for naming and docs
+            if (innerModel.name === "Record") {
+                // Record situation -> treat as array of dictionary
+                prop.isScalar = false;
+                prop.isAny = false;
+                prop.isOptional = property.optional;
+                prop.isCollection = true;
+                prop.isDict = true;
+                prop.typeName = {
+                    namespace: "",
+                    name: "dictionary"
+                };
+            }
+            else {
+                prop.isScalar = false;
+                prop.isAny = false;
+                prop.isOptional = property.optional;
+                prop.isCollection = true;
+                prop.typeName = getModelType(innerModel, rootNamespace, rootAlias);
+                if (!visited.has(model.name)) {
+                    prop.type = resolveModel(program, innerModel, visited, rootNamespace, rootAlias);
+                }
+            }
+        }
+        else {
+            // check for Scalar Arrays
+            const innerType = getTemplateType(model);
+            if (innerType && innerType.kind === "Scalar") {
+                prop.isScalar = true;
+                prop.isAny = false;
+                prop.isOptional = property.optional;
+                prop.isCollection = true;
+                prop.typeName = {
+                    namespace: "",
+                    name: getTypeName(innerType, { nameOnly: true })
+                };
+            }
+            else if (innerType && innerType.kind === "Intrinsic") {
+                prop.isScalar = true;
+                prop.isAny = true;
+                prop.isOptional = property.optional;
+                prop.isCollection = true;
+                prop.typeName = {
+                    namespace: "",
+                    name: "unknown"
+                };
+            }
+            else {
+                program.reportDiagnostic({
+                    code: "typra-emitter-unsupported-array-type",
+                    message: `Unsupported array type: ${getTypeName(model)}`,
+                    severity: "error",
+                    target: property
+                });
+            }
+        }
+    }
+    else {
+        prop.isScalar = false;
+        prop.isAny = false;
+        prop.isOptional = property.optional;
+        prop.isCollection = false;
+        prop.typeName = getModelType(model, rootNamespace, rootAlias);
+        if (prop.typeName.name === "Record<unknown>") {
+            prop.isScalar = true;
+            prop.isDict = true;
+            prop.typeName = {
+                namespace: "",
+                name: "dictionary"
+            };
+            // need to clear this out as a model type
+            prop.type = undefined;
+        }
+        if (!visited.has(model.name) && prop.typeName.name !== "dictionary") {
+            prop.type = resolveModel(program, model, visited, rootNamespace, rootAlias);
+        }
+    }
+    return prop;
+};
+export const resolveUnionProperty = (program, property, union, visited, rootNamespace, rootAlias) => {
+    const prop = new PropertyNode(property, getDoc(program, property) || "");
+    prop.isScalar = false;
+    prop.isAny = false;
+    prop.isOptional = property.optional;
+    prop.isCollection = false;
+    const variants = Array.from(union.variants).map(([, v]) => v.type);
+    const models = variants.filter(v => v.kind === "Model");
+    if (models.length === 1) {
+        prop.typeName = getModelType(models[0], rootNamespace, rootAlias);
+        if (!visited.has(models[0].name)) {
+            prop.type = resolveModel(program, models[0], visited, rootNamespace, rootAlias);
+        }
+    }
+    else if (models.length === 2) {
+        const modelNames = models.map(m => m.name);
+        // collection situation
+        if (modelNames.includes("Record") && modelNames.includes("Array")) {
+            // Should be Record<T> -> T
+            const recordType = getTemplateModel(models[modelNames.indexOf("Record")]);
+            // Should be Array<Named<T>> -> Named<T>
+            const namedType = getTemplateModel(models[modelNames.indexOf("Array")]);
+            // Should be Named<T> -> T
+            const arrayType = getTemplateModel(namedType);
+            if (recordType && arrayType && namedType && recordType.name === arrayType.name) {
+                prop.isCollection = true;
+                // Use T as actual class model for naming purposes
+                prop.typeName = getModelType(arrayType, rootNamespace, rootAlias);
+                // Use Named<T> for actual model props
+                if (!visited.has(arrayType.name)) {
+                    prop.type = resolveModel(program, namedType, visited, rootNamespace, rootAlias);
+                }
+            }
+            else {
+                program.reportDiagnostic({
+                    code: "typra-emitter-unsupported-union-types",
+                    message: `Unsupported union types for Record/Array: ${recordType?.name} / ${arrayType?.name} - they should match.`,
+                    severity: "error",
+                    target: property
+                });
+                return prop;
+            }
+        }
+        else if (modelNames.includes("Named")) {
+            const namedIdx = modelNames.indexOf("Named");
+            const namedModel = getTemplateModel(models[namedIdx]);
+            const mainModel = models[(namedIdx + 1) % 2];
+            if (namedModel && namedModel.name === mainModel.name) {
+                prop.typeName = getModelType(namedModel, rootNamespace, rootAlias);
+                if (!visited.has(mainModel.name)) {
+                    prop.type = resolveModel(program, namedModel, visited, rootNamespace, rootAlias);
+                }
+            }
+            else {
+                program.reportDiagnostic({
+                    code: "typra-emitter-named-model-union-types",
+                    message: `Named model union types must match! (${models.map(m => m.name).join(", ")})`,
+                    severity: "error",
+                    target: property
+                });
+                return prop;
+            }
+        }
+        else {
+            program.reportDiagnostic({
+                code: "typra-emitter-unsupported-union-types",
+                message: `Unsupported union type: ${union.kind}`,
+                severity: "error",
+                target: property
+            });
+            return prop;
+        }
+    }
+    else {
+        // string variants for `kind` scalar type
+        const acceptableVariants = variants.filter(v => v.kind === "String" || (v.kind === "Scalar" && v.name === "string")).length;
+        if (acceptableVariants === variants.length) {
+            prop.typeName = {
+                "namespace": "",
+                "name": "string"
+            };
+            prop.isScalar = true;
+            if (property.defaultValue && property.defaultValue.valueKind === "StringValue") {
+                prop.defaultValue = property.defaultValue?.value || null;
+            }
+            prop.allowedValues = variants.filter(v => v.kind === "String").map(v => v.value);
+            // Resolve enum type name from union.name (named unions) or alias name (alias statements)
+            let enumName = union.name;
+            if (!enumName && union.node) {
+                const node = union.node;
+                // For aliases: union.node is a UnionExpression whose parent is the AliasStatement
+                if (node.parent?.id?.sv && typeof node.parent.id.sv === "string") {
+                    // Guard against parent.id being a file path (happens for named union declarations)
+                    const parentId = node.parent.id.sv;
+                    if (!parentId.includes("/") && !parentId.includes("\\")) {
+                        enumName = parentId;
+                    }
+                }
+            }
+            if (enumName) {
+                prop.enumName = enumName;
+            }
+            // Check if the union includes a bare `string` scalar (open enum)
+            prop.isOpenEnum = variants.some(v => v.kind === "Scalar" && v.name === "string");
+        }
+        else {
+            program.reportDiagnostic({
+                code: "typra-emitter-unsupported-union-types",
+                message: `Unable to resolve ${union.name} - too many variants: (${models.map(m => m.name).join(", ")})`,
+                severity: "error",
+                target: property
+            });
+        }
+        return prop;
+    }
+    return prop;
+};
+const getTemplateModel = (type) => {
+    if (!type)
+        return undefined;
+    if (isTemplateInstance(type)) {
+        const t = type.templateMapper?.args.at(0);
+        if (t && t.entityKind === "Type" && t.kind === "Model") {
+            return t;
+        }
+    }
+    return undefined;
+};
+const getTemplateType = (type) => {
+    if (!type)
+        return undefined;
+    if (isTemplateInstance(type)) {
+        const t = type.templateMapper?.args.at(0);
+        if (t && t.entityKind === "Type") {
+            return t;
+        }
+    }
+    return undefined;
+};
+//# sourceMappingURL=ast.js.map