@fjall/generator 0.88.4 → 0.89.4

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

@@ -0,0 +1,25 @@
+import * as ts from "typescript";
+import type { ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+import { type ParsedValue } from "./astCommonParser.js";
+/** Parsed SQS queue resource from app.addMessaging(MessagingFactory.build(...)) */
+export interface ParsedSQSResource {
+    variableName?: string;
+    resourceName: string;
+    queueType: string;
+    visibilityTimeout?: number;
+    retentionPeriod?: number;
+    contentBasedDeduplication?: boolean;
+    extraProperties?: Array<{
+        key: string;
+        sourceText: string;
+    }>;
+    node: ts.Node;
+}
+export declare function parseDeadLetterQueueConfig(value: ParsedValue): {
+    enabled?: boolean;
+    maxReceiveCount?: number;
+} | false | undefined;
+/** Find all SQS resources from addMessaging calls */
+export declare function findSQSResources(sourceFile: ts.SourceFile): ParsedSQSResource[];
+/** Convert parsed SQS resources to plan format */
+export declare function convertSQSResources(sqsResources: ParsedSQSResource[]): ApplicationResourcePlan["sqs"];

package/dist/src/ast/astMessagingParser.js

@@ -0,0 +1,78 @@
+import * as ts from "typescript";
+import { asBoolean, asNumber, asString, captureExtraProperties, collectFromAst, extractVariableName, isFactoryBuildCall, isFactoryMethodCall, isParsedObject, omitUndefined, parseObjectLiteral, } from "./astCommonParser.js";
+// ---- Extraction helpers ----
+function extractSQSResource(addMessagingCall, 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;
+    }
+    const config = parseObjectLiteral(configArg);
+    const resource = {
+        resourceName: nameArg.text,
+        queueType: asString(config.queueType) ?? "standard",
+        visibilityTimeout: asNumber(config.visibilityTimeout),
+        retentionPeriod: asNumber(config.messageRetentionPeriod),
+        contentBasedDeduplication: asBoolean(config.contentBasedDeduplication),
+        node: addMessagingCall,
+    };
+    const varName = extractVariableName(addMessagingCall);
+    if (varName)
+        resource.variableName = varName;
+    const SQS_KNOWN_KEYS = new Set([
+        "type",
+        "queueType",
+        "visibilityTimeout",
+        "messageRetentionPeriod",
+        "contentBasedDeduplication",
+    ]);
+    const extras = captureExtraProperties(config, SQS_KNOWN_KEYS);
+    if (extras.length > 0)
+        resource.extraProperties = extras;
+    return resource;
+}
+// ---- Parsing for dead letter queue config (used by pattern parser) ----
+export function parseDeadLetterQueueConfig(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (value === false)
+        return false;
+    if (!isParsedObject(value))
+        return undefined;
+    return omitUndefined({
+        enabled: asBoolean(value.enabled),
+        maxReceiveCount: asNumber(value.maxReceiveCount),
+    });
+}
+// ---- Public API ----
+/** Find all SQS resources from addMessaging calls */
+export function findSQSResources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) ||
+            !isFactoryMethodCall(node, "addMessaging"))
+            return null;
+        const messagingArg = node.arguments[0];
+        if (!isFactoryBuildCall(messagingArg, "MessagingFactory"))
+            return null;
+        return extractSQSResource(node, messagingArg);
+    });
+}
+/** Convert parsed SQS resources to plan format */
+export function convertSQSResources(sqsResources) {
+    if (sqsResources.length === 0)
+        return undefined;
+    return sqsResources.map((queue) => ({
+        name: queue.resourceName,
+        queueType: queue.queueType === "fifo" ? "fifo" : "standard",
+        ...omitUndefined({
+            visibilityTimeout: queue.visibilityTimeout,
+            retentionPeriod: queue.retentionPeriod,
+            contentBasedDeduplication: queue.contentBasedDeduplication,
+            variableName: queue.variableName,
+            extraProperties: queue.extraProperties,
+        }),
+    }));
+}

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

@@ -0,0 +1,70 @@
+import * as ts from "typescript";
+import type { ApplicationResourcePlan, NetworkResourcePlan } from "../schemas/resourceSchemas.js";
+import { type ParsedObject } from "./astCommonParser.js";
+/** Parsed network configuration from App.getApp() options */
+export interface ParsedNetworkConfig {
+    maxAzs?: number;
+    natGateways?: {
+        count?: number;
+    } | false;
+    flowLogs?: {
+        destination?: string;
+        retentionDays?: number;
+    } | false;
+    vpcEndpoints?: ParsedObject;
+}
+/** Parsed additional network resource from app.addNetwork() */
+export interface ParsedNetworkResource {
+    variableName?: string;
+    name: string;
+    config: {
+        maxAzs?: number;
+        natGateways?: {
+            count?: number;
+        } | false;
+        flowLogs?: {
+            destination?: string;
+            retentionDays?: number;
+        } | false;
+        vpcEndpoints?: ParsedObject;
+    };
+    node: ts.Node;
+}
+/** Find VPC ID from App.getApp() network.useExisting option */
+export declare function findVpcId(sourceFile: ts.SourceFile): string | undefined;
+/** Extract the network configuration from App.getApp() options */
+export declare function findNetworkConfig(sourceFile: ts.SourceFile): ParsedNetworkConfig | undefined;
+/** Extract the backup configuration from App.getApp() options */
+export declare function findBackupConfig(sourceFile: ts.SourceFile): {
+    tier: string;
+} | false | undefined;
+/** Extract the tunnel configuration from App.getApp() options */
+export declare function findTunnelConfig(sourceFile: ts.SourceFile): {
+    instanceType?: string;
+} | boolean | undefined;
+/** Find all app.addNetwork() calls and extract their configuration */
+export declare function findNetworkResources(sourceFile: ts.SourceFile): ParsedNetworkResource[];
+/** Builds the conditional spread fields shared by primary and additional network configs */
+export declare function buildNetworkFields(config: {
+    maxAzs?: number;
+    natGateways?: {
+        count?: number;
+    } | false;
+    flowLogs?: {
+        destination?: string;
+        retentionDays?: number;
+    } | false;
+    vpcEndpoints?: ParsedObject | Record<string, unknown>;
+}): NetworkResourcePlan;
+/** Convert network config to plan format */
+export declare function convertNetworkConfig(network: ParsedNetworkConfig | undefined): ApplicationResourcePlan["network"];
+/** Convert backup config to plan format */
+export declare function convertBackupConfig(backup: {
+    tier: string;
+} | false | undefined): ApplicationResourcePlan["backup"];
+/** Convert tunnel config to plan format */
+export declare function convertTunnelConfig(tunnel: {
+    instanceType?: string;
+} | boolean | undefined): ApplicationResourcePlan["tunnel"];
+/** Convert additional network resources to plan format */
+export declare function convertAdditionalNetworks(networkResources: ParsedNetworkResource[]): ApplicationResourcePlan["additionalNetworks"];

package/dist/src/ast/astNetworkParser.js

@@ -0,0 +1,219 @@
+import * as ts from "typescript";
+import { constIncludes, BACKUP_VAULT_TIERS } from "../schemas/constants.js";
+import { asNumber, asString, collectFromAst, extractVariableName, findFirstInAst, isAppGetAppCall, isFactoryBuildCall, isFactoryMethodCall, isNamedProperty, isParsedObject, omitUndefined, parseObjectLiteral, parseBooleanOrConfig, } from "./astCommonParser.js";
+// ---- Flow log destination ----
+const FLOW_LOG_DESTINATIONS = ["cloudwatch", "s3"];
+function asFlowLogDestination(value) {
+    if (value === undefined)
+        return undefined;
+    return FLOW_LOG_DESTINATIONS.includes(value)
+        ? value
+        : undefined;
+}
+// ---- Network config parsing ----
+function parseNetworkConfigFields(parsed) {
+    return {
+        maxAzs: asNumber(parsed.maxAzs),
+        natGateways: parseBooleanOrConfig(parsed.natGateways, (v) => ({
+            count: asNumber(v.count),
+        })),
+        flowLogs: parseBooleanOrConfig(parsed.flowLogs, (v) => ({
+            destination: asString(v.destination),
+            retentionDays: asNumber(v.retentionDays),
+        })),
+        vpcEndpoints: isParsedObject(parsed.vpcEndpoints)
+            ? parsed.vpcEndpoints
+            : undefined,
+    };
+}
+// ---- Extraction helpers ----
+function extractNetworkResource(addNetworkCall, buildCall) {
+    if (buildCall.arguments.length < 2)
+        return null;
+    const nameArg = buildCall.arguments[0];
+    const configArg = buildCall.arguments[1];
+    if (!ts.isStringLiteral(nameArg))
+        return null;
+    const name = nameArg.text;
+    const parsed = ts.isObjectLiteralExpression(configArg)
+        ? parseObjectLiteral(configArg)
+        : {};
+    const networkFields = parseNetworkConfigFields(parsed);
+    const resource = {
+        name,
+        config: omitUndefined({ ...networkFields }),
+        node: addNetworkCall,
+    };
+    const varName = extractVariableName(addNetworkCall);
+    if (varName)
+        resource.variableName = varName;
+    return resource;
+}
+// ---- Public API ----
+/** Find VPC ID from App.getApp() network.useExisting option */
+export function findVpcId(sourceFile) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!isAppGetAppCall(node) || node.arguments.length <= 1)
+            return undefined;
+        const optionsArg = node.arguments[1];
+        if (!ts.isObjectLiteralExpression(optionsArg))
+            return undefined;
+        for (const prop of optionsArg.properties) {
+            if (isNamedProperty(prop, "network") &&
+                ts.isObjectLiteralExpression(prop.initializer)) {
+                for (const networkProp of prop.initializer.properties) {
+                    if (isNamedProperty(networkProp, "useExisting") &&
+                        ts.isStringLiteral(networkProp.initializer)) {
+                        return networkProp.initializer.text;
+                    }
+                }
+            }
+        }
+        return undefined;
+    });
+}
+/** Extract the network configuration from App.getApp() options */
+export function findNetworkConfig(sourceFile) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!isAppGetAppCall(node) || node.arguments.length <= 1)
+            return undefined;
+        const optionsArg = node.arguments[1];
+        if (!ts.isObjectLiteralExpression(optionsArg))
+            return undefined;
+        for (const prop of optionsArg.properties) {
+            if (isNamedProperty(prop, "network")) {
+                if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
+                    return undefined;
+                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                    const hasUseExisting = prop.initializer.properties.some((p) => isNamedProperty(p, "useExisting"));
+                    if (!hasUseExisting) {
+                        const parsed = parseObjectLiteral(prop.initializer);
+                        return parseNetworkConfigFields(parsed);
+                    }
+                }
+            }
+        }
+        return undefined;
+    });
+}
+/** Extract the backup configuration from App.getApp() options */
+export function findBackupConfig(sourceFile) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!isAppGetAppCall(node) || node.arguments.length <= 1)
+            return undefined;
+        const optionsArg = node.arguments[1];
+        if (!ts.isObjectLiteralExpression(optionsArg))
+            return undefined;
+        for (const prop of optionsArg.properties) {
+            if (isNamedProperty(prop, "backup")) {
+                if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
+                    return false;
+                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                    const parsed = parseObjectLiteral(prop.initializer);
+                    const tier = asString(parsed.tier);
+                    if (tier)
+                        return { tier };
+                }
+            }
+        }
+        return undefined;
+    });
+}
+/** Extract the tunnel configuration from App.getApp() options */
+export function findTunnelConfig(sourceFile) {
+    return findFirstInAst(sourceFile, (node) => {
+        if (!isAppGetAppCall(node) || node.arguments.length <= 1)
+            return undefined;
+        const optionsArg = node.arguments[1];
+        if (!ts.isObjectLiteralExpression(optionsArg))
+            return undefined;
+        for (const prop of optionsArg.properties) {
+            if (isNamedProperty(prop, "tunnel")) {
+                if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
+                    return false;
+                if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword)
+                    return true;
+                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                    const parsed = parseObjectLiteral(prop.initializer);
+                    const instanceType = asString(parsed.instanceType);
+                    if (instanceType)
+                        return { instanceType };
+                    return {};
+                }
+            }
+        }
+        return undefined;
+    });
+}
+/** Find all app.addNetwork() calls and extract their configuration */
+export function findNetworkResources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addNetwork"))
+            return null;
+        const networkArg = node.arguments[0];
+        if (!isFactoryBuildCall(networkArg, "NetworkFactory"))
+            return null;
+        return extractNetworkResource(node, networkArg);
+    });
+}
+// ---- Plan conversion ----
+/** Builds the conditional spread fields shared by primary and additional network configs */
+export function buildNetworkFields(config) {
+    const flowLogs = config.flowLogs;
+    return {
+        ...omitUndefined({
+            maxAzs: config.maxAzs,
+            natGateways: config.natGateways,
+            vpcEndpoints: config.vpcEndpoints,
+        }),
+        ...(flowLogs !== undefined && {
+            flowLogs: flowLogs === false
+                ? false
+                : omitUndefined({
+                    destination: asFlowLogDestination(flowLogs.destination),
+                    retentionDays: flowLogs.retentionDays,
+                }),
+        }),
+    };
+}
+/** Convert network config to plan format */
+export function convertNetworkConfig(network) {
+    if (!network)
+        return undefined;
+    return buildNetworkFields(network);
+}
+/** Convert backup config to plan format */
+export function convertBackupConfig(backup) {
+    if (backup === undefined)
+        return undefined;
+    if (backup === false)
+        return false;
+    const tier = backup.tier;
+    if (constIncludes(BACKUP_VAULT_TIERS, tier)) {
+        return { tier: tier };
+    }
+    return undefined;
+}
+/** Convert tunnel config to plan format */
+export function convertTunnelConfig(tunnel) {
+    if (tunnel === undefined)
+        return undefined;
+    if (tunnel === false)
+        return false;
+    if (tunnel === true)
+        return {};
+    const result = {};
+    if (tunnel.instanceType) {
+        result.instanceType = tunnel.instanceType;
+    }
+    return result;
+}
+/** Convert additional network resources to plan format */
+export function convertAdditionalNetworks(networkResources) {
+    if (!networkResources || networkResources.length === 0)
+        return undefined;
+    return networkResources.map((network) => ({
+        name: network.name,
+        ...buildNetworkFields(network.config),
+    }));
+}

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

@@ -0,0 +1,80 @@
+import * as ts from "typescript";
+import type { ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+/** Parsed Lambda function configuration */
+export interface ParsedLambdaConfig {
+    memorySize?: number;
+    timeout?: number;
+    ephemeralStorageSize?: number;
+}
+/** Parsed pattern resource from app.addPattern(PatternFactory.build(...)) */
+export interface ParsedPatternResource {
+    variableName?: string;
+    constructId: string;
+    type: "payload" | "nextjs";
+    config: {
+        name: string;
+        domain?: string;
+        database?: {
+            type?: "Instance" | "Aurora";
+            databaseName?: string;
+            databaseEngine?: "postgresql" | "mysql";
+            deletionProtection?: boolean;
+            backupRetention?: number;
+            port?: number;
+            publiclyAccessible?: boolean;
+            allowedIpCidr?: string;
+            instanceType?: string;
+            allocatedStorage?: number;
+            multiAz?: boolean;
+            allowVpcAccess?: boolean;
+            monitoringInterval?: number;
+            preferredMaintenanceWindow?: string;
+            snapshotIdentifier?: string;
+            snapshotUsername?: string;
+            readReplica?: object | false;
+            writer?: object;
+            readers?: object | false;
+            databaseInsights?: object | false;
+            proxy?: object | false;
+            credentials?: object;
+            encryption?: object;
+        };
+        compute?: {
+            server?: ParsedLambdaConfig;
+            imageOptimisation?: ParsedLambdaConfig;
+            revalidation?: ParsedLambdaConfig;
+        };
+        storage?: {
+            assets?: {
+                versioned?: boolean;
+            };
+            cache?: {
+                versioned?: boolean;
+            };
+            media?: {
+                versioned?: boolean;
+            };
+        };
+        messaging?: {
+            revalidationQueue?: {
+                visibilityTimeout?: number;
+                messageRetentionPeriod?: number;
+                maxMessageSize?: number;
+                deadLetterQueue?: {
+                    enabled?: boolean;
+                    maxReceiveCount?: number;
+                } | false;
+            };
+        };
+        cdn?: {
+            domainNames?: string[];
+            certificateArn?: string;
+        };
+        environment?: Record<string, string>;
+    };
+    node: ts.Node;
+}
+/** Find pattern resources from app.addPattern(PatternFactory.build(...)) calls */
+export declare function findPatternResources(sourceFile: ts.SourceFile): ParsedPatternResource[];
+/** Apply pattern config to plan */
+export declare function applyPatternConfig(plan: ApplicationResourcePlan, patternResources: ParsedPatternResource[]): void;

package/dist/src/ast/astPatternParser.js

@@ -0,0 +1,155 @@
+import * as ts from "typescript";
+import { asBoolean, asNumber, asString, asStringArray, asStringUnion, asObjectOrFalse, collectFromAst, extractSubConfig, extractVariableName, isFactoryBuildCall, isFactoryMethodCall, isParsedObject, parseObjectLiteral, parseOptionalConfig, typed, } from "./astCommonParser.js";
+import { parseDeadLetterQueueConfig } from "./astMessagingParser.js";
+// ---- Internal helpers ----
+const VALID_NON_GLOBAL_DB_TYPES = ["Instance", "Aurora"];
+const VALID_DB_ENGINES = ["postgresql", "mysql"];
+function parseLambdaConfig(obj) {
+    if (!isParsedObject(obj))
+        return undefined;
+    const config = {
+        ...(obj.memorySize !== undefined && {
+            memorySize: asNumber(obj.memorySize),
+        }),
+        ...(obj.timeout !== undefined && { timeout: asNumber(obj.timeout) }),
+        ...(obj.ephemeralStorageSize !== undefined && {
+            ephemeralStorageSize: asNumber(obj.ephemeralStorageSize),
+        }),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+function extractPatternDatabaseConfig(rawConfig) {
+    return extractSubConfig(rawConfig, "database", (db) => ({
+        type: asStringUnion(db.type, VALID_NON_GLOBAL_DB_TYPES),
+        databaseName: asString(db.databaseName),
+        databaseEngine: asStringUnion(db.databaseEngine, VALID_DB_ENGINES),
+        deletionProtection: asBoolean(db.deletionProtection),
+        backupRetention: asNumber(db.backupRetention),
+        port: asNumber(db.port),
+        publiclyAccessible: asBoolean(db.publiclyAccessible),
+        allowedIpCidr: asString(db.allowedIpCidr),
+        instanceType: asString(db.instanceType),
+        allocatedStorage: asNumber(db.allocatedStorage),
+        multiAz: asBoolean(db.multiAz),
+        allowVpcAccess: asBoolean(db.allowVpcAccess),
+        monitoringInterval: asNumber(db.monitoringInterval),
+        preferredMaintenanceWindow: asString(db.preferredMaintenanceWindow),
+        snapshotIdentifier: asString(db.snapshotIdentifier),
+        snapshotUsername: asString(db.snapshotUsername),
+        readReplica: asObjectOrFalse(db.readReplica),
+        writer: parseOptionalConfig(db.writer, typed()),
+        readers: asObjectOrFalse(db.readers),
+        databaseInsights: asObjectOrFalse(db.databaseInsights),
+        proxy: asObjectOrFalse(db.proxy),
+        credentials: parseOptionalConfig(db.credentials, typed()),
+        encryption: parseOptionalConfig(db.encryption, typed()),
+    }));
+}
+function extractPatternComputeConfig(rawConfig) {
+    return extractSubConfig(rawConfig, "compute", (compute) => ({
+        server: parseOptionalConfig(compute.server, parseLambdaConfig),
+        imageOptimisation: parseOptionalConfig(compute.imageOptimisation, parseLambdaConfig),
+        revalidation: parseOptionalConfig(compute.revalidation, parseLambdaConfig),
+    }));
+}
+function extractPatternStorageConfig(rawConfig) {
+    const parseVersionedConfig = (obj) => ({
+        versioned: asBoolean(obj.versioned),
+    });
+    return extractSubConfig(rawConfig, "storage", (storage) => ({
+        assets: parseOptionalConfig(storage.assets, parseVersionedConfig),
+        cache: parseOptionalConfig(storage.cache, parseVersionedConfig),
+        media: parseOptionalConfig(storage.media, parseVersionedConfig),
+    }));
+}
+function extractPatternMessagingConfig(rawConfig) {
+    return extractSubConfig(rawConfig, "messaging", (messaging) => ({
+        revalidationQueue: parseOptionalConfig(messaging.revalidationQueue, (queue) => ({
+            visibilityTimeout: asNumber(queue.visibilityTimeout),
+            messageRetentionPeriod: asNumber(queue.messageRetentionPeriod),
+            maxMessageSize: asNumber(queue.maxMessageSize),
+            deadLetterQueue: parseDeadLetterQueueConfig(queue.deadLetterQueue),
+        })),
+    }));
+}
+function extractPatternCdnConfig(rawConfig) {
+    return extractSubConfig(rawConfig, "cdn", (cdn) => ({
+        domainNames: asStringArray(cdn.domainNames),
+        certificateArn: asString(cdn.certificateArn),
+    }));
+}
+function extractPatternEnvironmentConfig(rawConfig) {
+    return extractSubConfig(rawConfig, "environment", (env) => {
+        const environment = Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
+        return Object.keys(environment).length > 0 ? environment : undefined;
+    });
+}
+function extractPatternResource(buildCall, addPatternCall) {
+    if (buildCall.arguments.length < 2)
+        return null;
+    const constructIdArg = buildCall.arguments[0];
+    const configArg = buildCall.arguments[1];
+    if (!ts.isStringLiteral(constructIdArg) ||
+        !ts.isObjectLiteralExpression(configArg)) {
+        return null;
+    }
+    const constructId = constructIdArg.text;
+    const rawConfig = parseObjectLiteral(configArg);
+    const patternType = rawConfig.type;
+    if (patternType !== "payload" && patternType !== "nextjs") {
+        return null;
+    }
+    const variableName = extractVariableName(addPatternCall);
+    const name = asString(rawConfig.name);
+    if (!name) {
+        return null;
+    }
+    return {
+        variableName,
+        constructId,
+        type: patternType,
+        config: {
+            name,
+            domain: asString(rawConfig.domain),
+            database: extractPatternDatabaseConfig(rawConfig),
+            compute: extractPatternComputeConfig(rawConfig),
+            storage: extractPatternStorageConfig(rawConfig),
+            messaging: extractPatternMessagingConfig(rawConfig),
+            cdn: extractPatternCdnConfig(rawConfig),
+            environment: extractPatternEnvironmentConfig(rawConfig),
+        },
+        node: buildCall,
+    };
+}
+// ---- Public API ----
+/** Find pattern resources from app.addPattern(PatternFactory.build(...)) calls */
+export function findPatternResources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addPattern"))
+            return null;
+        const patternArg = node.arguments[0];
+        if (!isFactoryBuildCall(patternArg, "PatternFactory"))
+            return null;
+        return extractPatternResource(patternArg, node);
+    });
+}
+/** Apply pattern config to plan */
+export function applyPatternConfig(plan, patternResources) {
+    if (!patternResources || patternResources.length === 0)
+        return;
+    const patternResource = patternResources[0];
+    if (patternResource.type !== "payload" && patternResource.type !== "nextjs")
+        return;
+    plan.pattern = patternResource.type;
+    plan.patternConfig = {
+        type: patternResource.type,
+        name: patternResource.config.name,
+        domain: patternResource.config.domain,
+        database: patternResource.config.database,
+        compute: patternResource.config.compute,
+        storage: patternResource.config.storage,
+        messaging: patternResource.config.messaging,
+        cdn: patternResource.config.cdn,
+        environment: patternResource.config.environment,
+    };
+}

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

@@ -0,0 +1,18 @@
+import * as ts from "typescript";
+import { type ApplicationResourcePlan } from "../schemas/resourceSchemas.js";
+import { type ParsedObject } from "./astCommonParser.js";
+declare const S3_BUCKET_CLASSES: Set<string>;
+export { S3_BUCKET_CLASSES };
+export interface ParsedS3Resource {
+    variableName: string;
+    resourceName: string;
+    bucketClass: string;
+    config: ParsedObject;
+    node: ts.Node;
+}
+/** Find S3 resources created via new S3Bucket() constructor pattern */
+export declare function findS3Resources(sourceFile: ts.SourceFile): ParsedS3Resource[];
+/** Find S3 resources created via app.addStorage(StorageFactory.build(...)) factory pattern */
+export declare function findS3FactoryResources(sourceFile: ts.SourceFile): ParsedS3Resource[];
+/** Convert parsed S3 resources to plan format */
+export declare function convertS3Resources(s3Resources: ParsedS3Resource[]): ApplicationResourcePlan["s3"];