@fjall/generator 0.88.4 → 0.89.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fjall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/ast/astCdnParser.d.ts

@@ -0,0 +1,15 @@
+import * as ts from "typescript";
+import type { ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+import { type ParsedObject } from "./astCommonParser.js";
+import type { ParsedS3Resource } from "./astStorageParser.js";
+import type { ParsedComputeResource } from "./astComputeParser.js";
+/** Parsed CDN resource from app.addCdn(CdnFactory.build(...)) */
+export interface ParsedCDNResource {
+    resourceName: string;
+    config: ParsedObject;
+    node: ts.Node;
+}
+/** Find CDN resource from addCdn call */
+export declare function findCDNResource(sourceFile: ts.SourceFile): ParsedCDNResource | undefined;
+/** Convert parsed CDN resource to plan format */
+export declare function convertCDNResource(cdnResource: ParsedCDNResource | undefined, s3Resources: ParsedS3Resource[], computeResources: ParsedComputeResource[]): ApplicationResourcePlan["cdn"];

package/dist/src/ast/astCdnParser.js

@@ -0,0 +1,114 @@
+import * as ts from "typescript";
+import { asString, asStringArray, asStringUnion, captureExtraProperties, findFirstInAst, isFactoryBuildCall, isFactoryMethodCall, isIdentifierRef, isParsedObject, parseObjectLiteral, } from "./astCommonParser.js";
+// ---- Extraction helpers ----
+function extractCDNResource(buildCall) {
+    if (buildCall.arguments.length < 2)
+        return null;
+    const nameArg = buildCall.arguments[0];
+    const configArg = buildCall.arguments[1];
+    if (!ts.isStringLiteral(nameArg) ||
+        !ts.isObjectLiteralExpression(configArg)) {
+        return null;
+    }
+    return {
+        resourceName: nameArg.text,
+        config: parseObjectLiteral(configArg),
+        node: buildCall,
+    };
+}
+/** Resolve a CDN origin identifier back to its resource name */
+function resolveOriginIdentifier(identifier, s3Resources, computeResources) {
+    const s3Match = s3Resources.find((s3) => s3.variableName === identifier);
+    if (s3Match)
+        return s3Match.resourceName;
+    const computeMatch = computeResources.find((c) => c.variableName === identifier ||
+        c.resourceName.charAt(0).toLowerCase() + c.resourceName.slice(1) ===
+            identifier);
+    if (computeMatch)
+        return computeMatch.resourceName;
+    return identifier;
+}
+const CDN_CACHE_POLICIES = ["CACHING_OPTIMIZED", "CACHING_DISABLED"];
+// ---- Public API ----
+/** Find CDN resource from addCdn call */
+export function findCDNResource(sourceFile) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addCdn"))
+            return undefined;
+        const cdnArg = node.arguments[0];
+        if (!isFactoryBuildCall(cdnArg, "CdnFactory"))
+            return undefined;
+        return extractCDNResource(cdnArg) ?? undefined;
+    });
+}
+/** Convert parsed CDN resource to plan format */
+export function convertCDNResource(cdnResource, s3Resources, computeResources) {
+    if (!cdnResource)
+        return undefined;
+    const cdn = cdnResource;
+    const config = cdn.config;
+    const resolveOrigin = (val) => {
+        if (isIdentifierRef(val)) {
+            return resolveOriginIdentifier(val.__identifier, s3Resources, computeResources);
+        }
+        return asString(val) ?? "";
+    };
+    const defaultOriginRef = resolveOrigin(config.origin);
+    const result = {
+        name: cdn.resourceName,
+        defaultOriginRef,
+    };
+    if (Array.isArray(config.behaviours)) {
+        const behaviours = config.behaviours.filter(isParsedObject).map((b) => ({
+            pathPattern: asString(b.pathPattern) ?? "",
+            originRef: resolveOrigin(b.origin),
+            ...{
+                ...(asStringUnion(b.cachePolicy, CDN_CACHE_POLICIES) !== undefined && {
+                    cachePolicy: asStringUnion(b.cachePolicy, CDN_CACHE_POLICIES),
+                }),
+            },
+        }));
+        if (behaviours.length > 0)
+            result.behaviours = behaviours;
+    }
+    const customDomain = asString(config.customDomain);
+    if (customDomain) {
+        result.customDomain = customDomain;
+    }
+    else {
+        const domainNames = asStringArray(config.domainNames);
+        if (domainNames && domainNames.length > 0) {
+            result.customDomain = domainNames[0];
+        }
+    }
+    const certificateArn = asString(config.certificateArn);
+    if (certificateArn)
+        result.certificateArn = certificateArn;
+    if (config.accessGate !== undefined) {
+        if (config.accessGate === false) {
+            result.accessGate = false;
+        }
+        else if (isParsedObject(config.accessGate)) {
+            const gate = config.accessGate;
+            const gateType = asString(gate.type);
+            const username = asString(gate.username);
+            const password = asString(gate.password);
+            if (gateType === "basic-auth" && username && password) {
+                result.accessGate = { type: "basic-auth", username, password };
+            }
+        }
+    }
+    const CDN_KNOWN_KEYS = new Set([
+        "originType",
+        "origin",
+        "behaviours",
+        "customDomain",
+        "domainNames",
+        "certificateArn",
+        "accessGate",
+    ]);
+    const extras = captureExtraProperties(config, CDN_KNOWN_KEYS);
+    if (extras.length > 0)
+        result.extraProperties = extras;
+    return result;
+}

package/dist/src/ast/astCommonParser.d.ts

@@ -0,0 +1,90 @@
+import * as ts from "typescript";
+import type { ExtraProperty } from "../schemas/resourceSchemas.js";
+/** Special marker for identifier references in parsed AST */
+export interface IdentifierRef {
+    __identifier: string;
+}
+/** Special marker for property access expressions in parsed AST */
+export interface ExpressionRef {
+    __expression: string;
+}
+/** Special marker for function call expressions in parsed AST */
+export interface CallRef {
+    __call: string;
+}
+/** Special marker for unknown/unsupported expressions in parsed AST */
+interface UnknownRef {
+    __unknown: string;
+}
+/** Union of all possible values that can be parsed from AST expressions */
+export type ParsedValue = string | number | boolean | null | undefined | IdentifierRef | ExpressionRef | CallRef | UnknownRef | ParsedValue[] | ParsedObject;
+/** Object with string keys and parsed values */
+export type ParsedObject = {
+    [key: string]: ParsedValue;
+};
+/** Base check for non-null, non-array objects */
+export declare function isPlainObject(value: ParsedValue): value is Record<string, ParsedValue>;
+/** Type guard for identifier references */
+export declare function isIdentifierRef(value: ParsedValue): value is IdentifierRef;
+/** Type guard for expression references */
+export declare function isExpressionRef(value: ParsedValue): value is ExpressionRef;
+/** Type guard for call references */
+export declare function isCallRef(value: ParsedValue): value is CallRef;
+/** Type guard for parsed objects */
+export declare function isParsedObject(value: ParsedValue): value is ParsedObject;
+/** Safely extract a string from ParsedValue */
+export declare function asString(value: ParsedValue): string | undefined;
+/** Safely extract a number from ParsedValue */
+export declare function asNumber(value: ParsedValue): number | undefined;
+/** Safely extract a boolean from ParsedValue */
+export declare function asBoolean(value: ParsedValue): boolean | undefined;
+/** Safely extract a string array from ParsedValue */
+export declare function asStringArray(value: ParsedValue): string[] | undefined;
+/** Narrow a string to a union member, returning undefined if not a valid member */
+export declare function asStringUnion<T extends readonly string[]>(value: ParsedValue | undefined, validValues: T): T[number] | undefined;
+/** Returns a shallow copy with all undefined-valued properties removed */
+export declare function omitUndefined<T extends Record<string, unknown>>(obj: T): Partial<T>;
+/** Reconstruct source text from a parsed AST value for round-trip preservation */
+export declare function parsedValueToSourceText(value: ParsedValue): string;
+/** Capture properties from a parsed config that are NOT in the known keys set */
+export declare function captureExtraProperties(config: ParsedObject, knownKeys: Set<string>): ExtraProperty[];
+/** Check if an object literal property is a named property assignment */
+export declare function isNamedProperty(prop: ts.ObjectLiteralElementLike, name: string): prop is ts.PropertyAssignment;
+/** Check if a node is an App.getApp() call expression */
+export declare function isAppGetAppCall(node: ts.Node): node is ts.CallExpression;
+/** Check if a node is a chained factory method call (e.g., app.addDatabase(...)) */
+export declare function isFactoryMethodCall(node: ts.CallExpression, methodName: string): boolean;
+/** Traverse AST and return the first non-undefined result from the finder. */
+export declare function findFirstInAst<T>(sourceFile: ts.SourceFile, finder: (node: ts.Node) => T | undefined): T | undefined;
+/** Traverse AST and collect all non-null results from the collector. */
+export declare function collectFromAst<T>(sourceFile: ts.SourceFile, collector: (node: ts.Node) => T | null): T[];
+/** Type guard for Factory.build() call expressions */
+export declare function isFactoryBuildCall(node: ts.Node, factoryName: string): node is ts.CallExpression;
+/** Extract variable name from the parent declaration of a node */
+export declare function extractVariableName(node: ts.Node): string | undefined;
+/** Identity cast - trusts that parsed CDK output matches the expected shape.
+ * Safe because input is always generated CDK code that was originally validated by Zod schemas. */
+export declare const typed: <T>() => (v: ParsedObject) => T;
+/** Safely extract an object or false from ParsedValue */
+export declare function asObjectOrFalse(value: ParsedValue): object | false | undefined;
+export declare function parseBooleanOrConfig<T>(value: ParsedValue | undefined, cast: (v: ParsedObject) => T): T | false | undefined;
+export declare function parseOptionalConfig<T>(value: ParsedValue | undefined, parser: (obj: ParsedObject) => T): T | undefined;
+/** Extract a named sub-object from a config, returning undefined if not a plain object */
+export declare function extractSubConfig<T>(rawConfig: ParsedObject, field: string, transform: (obj: ParsedObject) => T): T | undefined;
+/** Parse an object literal expression into a ParsedObject */
+export declare function parseObjectLiteral(node: ts.ObjectLiteralExpression): ParsedObject;
+/** Evaluate a TypeScript AST expression to a ParsedValue */
+export declare function evaluateExpression(node: ts.Expression): ParsedValue;
+/** Find a string variable value by name */
+export declare function findVariableValue(sourceFile: ts.SourceFile, varName: string): string | undefined;
+/** Find an object variable declaration by name */
+export declare function findObjectDeclaration(sourceFile: ts.SourceFile, objName: string): ParsedObject | undefined;
+/** Evaluate a property access expression to a string */
+export declare function evaluatePropertyAccess(sourceFile: ts.SourceFile, node: ts.PropertyAccessExpression): string | undefined;
+/**
+ * Resolve a template literal expression to its string value.
+ * Walks spans: head.text + resolve each span.expression + span.literal.text.
+ * Falls back to stripping backticks from getText() if resolution fails.
+ */
+export declare function resolveTemplateLiteral(sourceFile: ts.SourceFile, templateExpr: ts.TemplateExpression): string;
+export {};

package/dist/src/ast/astCommonParser.js

@@ -0,0 +1,351 @@
+import * as ts from "typescript";
+import { constIncludes } from "../schemas/constants.js";
+/** Base check for non-null, non-array objects */
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Type guard for identifier references */
+export function isIdentifierRef(value) {
+    return isPlainObject(value) && "__identifier" in value;
+}
+/** Type guard for expression references */
+export function isExpressionRef(value) {
+    return isPlainObject(value) && "__expression" in value;
+}
+/** Type guard for call references */
+export function isCallRef(value) {
+    return isPlainObject(value) && "__call" in value;
+}
+/** Type guard for parsed objects */
+export function isParsedObject(value) {
+    return (isPlainObject(value) &&
+        !("__identifier" in value) &&
+        !("__expression" in value) &&
+        !("__call" in value) &&
+        !("__unknown" in value));
+}
+/** Safely extract a string from ParsedValue */
+export function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Safely extract a number from ParsedValue */
+export function asNumber(value) {
+    return typeof value === "number" ? value : undefined;
+}
+/** Safely extract a boolean from ParsedValue */
+export function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+/** Safely extract a string array from ParsedValue */
+export function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const result = [];
+    for (const item of value) {
+        if (typeof item === "string")
+            result.push(item);
+    }
+    return result.length > 0 ? result : undefined;
+}
+/** Narrow a string to a union member, returning undefined if not a valid member */
+export function asStringUnion(value, validValues) {
+    const str = asString(value);
+    if (str === undefined)
+        return undefined;
+    return constIncludes(validValues, str) ? str : undefined;
+}
+/** Returns a shallow copy with all undefined-valued properties removed */
+export function omitUndefined(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/** Reconstruct source text from a parsed AST value for round-trip preservation */
+export function parsedValueToSourceText(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (Array.isArray(value)) {
+        return `[${value.map(parsedValueToSourceText).join(", ")}]`;
+    }
+    if (!isPlainObject(value))
+        return String(value);
+    if (isIdentifierRef(value))
+        return value.__identifier;
+    if (isExpressionRef(value))
+        return value.__expression;
+    if (isCallRef(value))
+        return value.__call;
+    if ("__unknown" in value && typeof value.__unknown === "string")
+        return value.__unknown;
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return "{}";
+    const inner = entries
+        .map(([k, v]) => `${k}: ${parsedValueToSourceText(v)}`)
+        .join(", ");
+    return `{ ${inner} }`;
+}
+/** Capture properties from a parsed config that are NOT in the known keys set */
+export function captureExtraProperties(config, knownKeys) {
+    const extras = [];
+    for (const [key, value] of Object.entries(config)) {
+        if (knownKeys.has(key) || value === undefined)
+            continue;
+        extras.push({ key, sourceText: parsedValueToSourceText(value) });
+    }
+    return extras;
+}
+/** Check if an object literal property is a named property assignment */
+export function isNamedProperty(prop, name) {
+    return (ts.isPropertyAssignment(prop) &&
+        ts.isIdentifier(prop.name) &&
+        prop.name.text === name);
+}
+/** Check if a node is an App.getApp() call expression */
+export function isAppGetAppCall(node) {
+    return (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "getApp" &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === "App");
+}
+/** Check if a node is a chained factory method call (e.g., app.addDatabase(...)) */
+export function isFactoryMethodCall(node, methodName) {
+    const { expression } = node;
+    return (ts.isPropertyAccessExpression(expression) &&
+        expression.name.text === methodName &&
+        node.arguments.length > 0);
+}
+/** Traverse AST and return the first non-undefined result from the finder. */
+export function findFirstInAst(sourceFile, finder) {
+    let result;
+    const visit = (node) => {
+        if (result !== undefined)
+            return;
+        result = finder(node);
+        if (result === undefined)
+            ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return result;
+}
+/** Traverse AST and collect all non-null results from the collector. */
+export function collectFromAst(sourceFile, collector) {
+    const results = [];
+    const visit = (node) => {
+        const item = collector(node);
+        if (item !== null)
+            results.push(item);
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return results;
+}
+/** Type guard for Factory.build() call expressions */
+export function isFactoryBuildCall(node, factoryName) {
+    return (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "build" &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === factoryName);
+}
+/** Extract variable name from the parent declaration of a node */
+export function extractVariableName(node) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    return undefined;
+}
+/** Identity cast - trusts that parsed CDK output matches the expected shape.
+ * Safe because input is always generated CDK code that was originally validated by Zod schemas. */
+export const typed = () => (v) => v;
+/** Safely extract an object or false from ParsedValue */
+export function asObjectOrFalse(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (value === false)
+        return false;
+    if (typeof value === "object" && !Array.isArray(value))
+        return value;
+    return undefined;
+}
+export function parseBooleanOrConfig(value, cast) {
+    if (value === false)
+        return false;
+    return isParsedObject(value) ? cast(value) : undefined;
+}
+export function parseOptionalConfig(value, parser) {
+    return isParsedObject(value) ? parser(value) : undefined;
+}
+/** Extract a named sub-object from a config, returning undefined if not a plain object */
+export function extractSubConfig(rawConfig, field, transform) {
+    const value = rawConfig[field];
+    return isParsedObject(value) ? transform(value) : undefined;
+}
+/** Parse an object literal expression into a ParsedObject */
+export function parseObjectLiteral(node) {
+    const result = {};
+    for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = ts.isIdentifier(prop.name)
+            ? prop.name.text
+            : ts.isStringLiteral(prop.name)
+                ? prop.name.text
+                : undefined;
+        if (key === undefined)
+            continue;
+        result[key] = evaluateExpression(prop.initializer);
+    }
+    return result;
+}
+/** Evaluate a TypeScript AST expression to a ParsedValue */
+export function evaluateExpression(node) {
+    if (ts.isStringLiteral(node)) {
+        return node.text;
+    }
+    else if (ts.isNumericLiteral(node)) {
+        return Number(node.text);
+    }
+    else if (node.kind === ts.SyntaxKind.TrueKeyword) {
+        return true;
+    }
+    else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+        return false;
+    }
+    else if (ts.isArrayLiteralExpression(node)) {
+        return node.elements.map((element) => evaluateExpression(element));
+    }
+    else if (ts.isObjectLiteralExpression(node)) {
+        return parseObjectLiteral(node);
+    }
+    else if (ts.isIdentifier(node)) {
+        return { __identifier: node.text };
+    }
+    else if (ts.isPropertyAccessExpression(node)) {
+        return { __expression: node.getText() };
+    }
+    else if (ts.isCallExpression(node)) {
+        return { __call: node.getText() };
+    }
+    else if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+        // Handle || operator - return the left side if it's a literal
+        const left = evaluateExpression(node.left);
+        const right = evaluateExpression(node.right);
+        // For simplicity, prefer string literals from the right side for defaults
+        if (typeof right === "string") {
+            return right;
+        }
+        return left;
+    }
+    else if (ts.isConditionalExpression(node)) {
+        // Handle ternary operator - for simplicity, try to evaluate the branches
+        const whenTrue = evaluateExpression(node.whenTrue);
+        const whenFalse = evaluateExpression(node.whenFalse);
+        // Default to the false branch for simplicity
+        if (typeof whenFalse === "string" || typeof whenFalse === "number") {
+            return whenFalse;
+        }
+        return whenTrue;
+    }
+    else if (ts.isTemplateExpression(node) ||
+        ts.isNoSubstitutionTemplateLiteral(node)) {
+        // Handle template literals to preserve them as expressions during round-trip parsing
+        return { __expression: node.getText() };
+    }
+    return { __unknown: node.getText() };
+}
+/** Find a string variable value by name */
+export function findVariableValue(sourceFile, varName) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!ts.isVariableStatement(node))
+            return undefined;
+        for (const declaration of node.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) &&
+                declaration.name.text === varName &&
+                declaration.initializer) {
+                if (ts.isStringLiteral(declaration.initializer)) {
+                    return declaration.initializer.text;
+                }
+                if (ts.isObjectLiteralExpression(declaration.initializer)) {
+                    const obj = parseObjectLiteral(declaration.initializer);
+                    return JSON.stringify(obj);
+                }
+            }
+        }
+        return undefined;
+    });
+}
+/** Find an object variable declaration by name */
+export function findObjectDeclaration(sourceFile, objName) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!ts.isVariableStatement(node))
+            return undefined;
+        for (const declaration of node.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) &&
+                declaration.name.text === objName &&
+                declaration.initializer &&
+                ts.isObjectLiteralExpression(declaration.initializer)) {
+                return parseObjectLiteral(declaration.initializer);
+            }
+        }
+        return undefined;
+    });
+}
+/** Evaluate a property access expression to a string */
+export function evaluatePropertyAccess(sourceFile, node) {
+    if (!ts.isIdentifier(node.expression))
+        return undefined;
+    const objValue = findObjectDeclaration(sourceFile, node.expression.text);
+    const propName = node.name.text;
+    if (objValue && objValue[propName] !== undefined) {
+        return String(objValue[propName]);
+    }
+    return undefined;
+}
+/**
+ * Resolve a template literal expression to its string value.
+ * Walks spans: head.text + resolve each span.expression + span.literal.text.
+ * Falls back to stripping backticks from getText() if resolution fails.
+ */
+export function resolveTemplateLiteral(sourceFile, templateExpr) {
+    let result = templateExpr.head.text;
+    for (const span of templateExpr.templateSpans) {
+        if (ts.isIdentifier(span.expression)) {
+            const resolved = findVariableValue(sourceFile, span.expression.text);
+            if (resolved) {
+                result += resolved;
+            }
+            else {
+                // Can't resolve -- fall back to raw getText()
+                return templateExpr.getText(sourceFile).replace(/^`|`$/g, "");
+            }
+        }
+        else if (ts.isPropertyAccessExpression(span.expression)) {
+            const resolved = evaluatePropertyAccess(sourceFile, span.expression);
+            if (resolved) {
+                result += resolved;
+            }
+            else {
+                return templateExpr.getText(sourceFile).replace(/^`|`$/g, "");
+            }
+        }
+        else {
+            return templateExpr.getText(sourceFile).replace(/^`|`$/g, "");
+        }
+        result += span.literal.text;
+    }
+    return result;
+}

package/dist/src/ast/astComputeParser.d.ts

@@ -1,4 +1,16 @@
-import { type ParsedInfrastructure } from "./astInfrastructureParser.js";
+import * as ts from "typescript";
+import { type ParsedObject } from "./astCommonParser.js";
 import { type ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+import type { ParsedDatabaseResource } from "./astDatabaseParser.js";
+import type { ParsedS3Resource } from "./astStorageParser.js";
+export interface ParsedComputeResource {
+    variableName?: string;
+    resourceName: string;
+    type: string;
+    config: ParsedObject;
+    node: ts.Node;
+}
+/** Find all compute resources from addCompute calls */
+export declare function findComputeResources(sourceFile: ts.SourceFile): ParsedComputeResource[];
 /** Convert parsed compute resources to plan format */
-export declare function convertComputeResources(parsed: ParsedInfrastructure, plan: ApplicationResourcePlan): ApplicationResourcePlan["compute"];
+export declare function convertComputeResources(computeResources: ParsedComputeResource[], databaseResources: ParsedDatabaseResource[], s3Resources: ParsedS3Resource[], plan: ApplicationResourcePlan): ApplicationResourcePlan["compute"];