@fjall/generator 0.88.4 → 0.89.2

package/dist/src/ast/astComputeParser.js

@@ -1,5 +1,43 @@
-import { isPlainObject, isParsedObject, isIdentifierRef, isExpressionRef, isCallRef, asString, asNumber, asBoolean, asStringArray, asStringUnion, captureExtraProperties, } from "./astInfrastructureParser.js";
+import * as ts from "typescript";
+import { isPlainObject, isParsedObject, isIdentifierRef, isExpressionRef, isCallRef, asString, asNumber, asBoolean, asStringArray, asStringUnion, captureExtraProperties, collectFromAst, extractVariableName, isFactoryBuildCall, isFactoryMethodCall, parseObjectLiteral, } from "./astCommonParser.js";
 import { COMPUTE_TYPES, DEPLOYMENT_TYPES, EC2_INSTANCE_TYPES, ECS_CAPACITY_PROVIDERS, } from "../schemas/constants.js";
+// ---- Extraction helpers ----
+function extractComputeResource(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 resourceName = nameArg.text;
+    const config = parseObjectLiteral(configArg);
+    return {
+        resourceName,
+        type: asString(config.type) ?? "ecs",
+        config,
+        node: buildCall,
+    };
+}
+/** Find all compute resources from addCompute calls */
+export function findComputeResources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addCompute"))
+            return null;
+        const computeArg = node.arguments[0];
+        if (!isFactoryBuildCall(computeArg, "ComputeFactory"))
+            return null;
+        const resource = extractComputeResource(computeArg);
+        if (resource) {
+            const varName = extractVariableName(node);
+            if (varName)
+                resource.variableName = varName;
+        }
+        return resource;
+    });
+}
+// ---- Internal helpers ----
 const MAX_DATABASE_CONNECTION_INDICES = 10;
 const LOAD_BALANCER_TYPES = ["public", "internal"];
 function isEnvironmentRecord(value) {
@@ -97,12 +135,20 @@ function parseServiceScaling(scalingVal) {
 function parseServiceEc2Config(ec2ConfigVal) {
     if (!isParsedObject(ec2ConfigVal))
         return undefined;
+    const warmPoolVal = ec2ConfigVal.warmPool;
+    const warmPool = isParsedObject(warmPoolVal)
+        ? {
+            minSize: asNumber(warmPoolVal.minSize),
+            reuseOnScaleIn: asBoolean(warmPoolVal.reuseOnScaleIn),
+        }
+        : undefined;
     return {
         instanceType: asString(ec2ConfigVal.instanceType),
         amiHardwareType: asStringUnion(ec2ConfigVal.amiHardwareType, AMI_HARDWARE_TYPES),
         minCapacity: asNumber(ec2ConfigVal.minCapacity),
         maxCapacity: asNumber(ec2ConfigVal.maxCapacity),
         memoryLimitMiB: asNumber(ec2ConfigVal.memoryLimitMiB),
+        warmPool,
     };
 }
 /** Resolve connected database names from AST connection references */
@@ -259,7 +305,7 @@ function convertEcsCompute(compute, computePlan) {
     if (extras.length > 0)
         computePlan.extraProperties = extras;
 }
-/** Extract a string from a literal or an expression like `Prefix.VALUE` → "VALUE" */
+/** Extract a string from a literal or an expression like `Prefix.VALUE` -> "VALUE" */
 function extractEnumString(value, prefix) {
     const str = asString(value);
     if (str)
@@ -279,10 +325,10 @@ function extractCallStringArg(value) {
 function convertLambdaCompute(compute, computePlan) {
     assignIfDefined(computePlan, "deployment", asStringUnion(compute.config.deployment, DEPLOYMENT_TYPES));
     assignIfDefined(computePlan, "timeout", asNumber(compute.config.timeout));
-    // Code gen emits `memorySize` but plan field is `memory` — handle both keys
+    // Code gen emits `memorySize` but plan field is `memory` -- handle both keys
     assignIfDefined(computePlan, "memory", asNumber(compute.config.memorySize) ?? asNumber(compute.config.memory));
     assignIfDefined(computePlan, "handler", asString(compute.config.handler));
-    // Code gen emits `runtime: Runtime.NODEJS_20_X` — extract enum value from expression
+    // Code gen emits `runtime: Runtime.NODEJS_20_X` -- extract enum value from expression
     assignIfDefined(computePlan, "runtime", extractEnumString(compute.config.runtime, "Runtime"));
     if (isEnvironmentRecord(compute.config.environment)) {
         computePlan.environment = compute.config.environment;
@@ -312,7 +358,7 @@ function convertLambdaCompute(compute, computePlan) {
             computePlan.codePath = codePath;
         }
     }
-    // CDK prop is `lambdaDescription` — plan stores as `description`
+    // CDK prop is `lambdaDescription` -- plan stores as `description`
     assignIfDefined(computePlan, "description", asString(compute.config.lambdaDescription));
     assignIfDefined(computePlan, "scheduleExpression", asString(compute.config.scheduleExpression));
     assignIfDefined(computePlan, "architecture", extractEnumString(compute.config.architecture, "Architecture"));
@@ -347,7 +393,7 @@ function convertLambdaCompute(compute, computePlan) {
 }
 function convertEc2Compute(compute, computePlan) {
     assignIfDefined(computePlan, "instanceType", asStringUnion(compute.config.instanceType, EC2_INSTANCE_TYPES));
-    // Code gen emits `ssh: {}` or `ssh: false` — map to enableSSH boolean.
+    // Code gen emits `ssh: {}` or `ssh: false` -- map to enableSSH boolean.
     // Also accept `enableSSH: true/false` for manually-written code.
     const sshVal = compute.config.ssh;
     if (sshVal === false) {
@@ -408,8 +454,8 @@ function applyTypeSpecificConfig(computePlan, compute) {
     TYPE_CONVERTERS[computePlan.type]?.(compute, computePlan);
 }
 /** Convert parsed compute resources to plan format */
-export function convertComputeResources(parsed, plan) {
-    return parsed.computeResources.map((compute) => {
+export function convertComputeResources(computeResources, databaseResources, s3Resources, plan) {
+    return computeResources.map((compute) => {
         const computeType = asStringUnion(compute.config.type, COMPUTE_TYPES) ?? "ecs";
         const computePlan = {
             name: compute.resourceName,
@@ -418,7 +464,7 @@ export function convertComputeResources(parsed, plan) {
             connectedDatabase: [],
             ...(compute.variableName && { variableName: compute.variableName }),
         };
-        applyConnectionConfig(computePlan, compute, parsed.databaseResources, parsed.s3Resources);
+        applyConnectionConfig(computePlan, compute, databaseResources, s3Resources);
         applyTypeSpecificConfig(computePlan, compute);
         inferDatabaseConnectionsFromEnv(computePlan, compute.config.services, plan.database);
         inferStorageConnectionsFromEnv(computePlan, compute.config.services, plan.s3);

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

@@ -0,0 +1,104 @@
+import * as ts from "typescript";
+import type { ApplicationResourcePlan, ExtraProperty } from "../schemas/resourceSchemas.js";
+interface ParsedProxyConfig {
+    maxConnections?: number;
+    maxIdleConnections?: number;
+    connectionBorrowTimeout?: number;
+    requireTLS?: boolean;
+}
+interface ParsedReadReplicaConfig {
+    instanceType?: string;
+    availabilityZone?: string;
+}
+interface ParsedCredentialsConfig {
+    username?: string;
+    secretRotation?: {
+        automaticallyAfterDays?: number;
+    };
+}
+interface ParsedDatabaseInsightsConfig {
+    mode?: "standard" | "advanced";
+    encryptionKey?: {
+        awsManaged: true;
+    };
+}
+interface ParsedEncryptionConfig {
+    storageKey?: {
+        awsManaged: true;
+    };
+}
+interface ParsedAuroraWriterConfig {
+    enableDatabaseInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+interface ParsedAuroraReadersConfig {
+    count?: number;
+    defaultEnableDatabaseInsights?: boolean;
+}
+export interface ParsedDatabaseResource {
+    variableName?: string;
+    resourceName: string;
+    type: string;
+    databaseName: string;
+    databaseEngine?: "postgresql" | "mysql";
+    engineExpression?: string;
+    port?: number;
+    deletionProtection?: boolean;
+    instanceType?: string;
+    multiAz?: boolean;
+    publiclyAccessible?: boolean;
+    enableSecretRotation?: boolean;
+    encryption?: ParsedEncryptionConfig;
+    databaseInsights?: ParsedDatabaseInsightsConfig | false;
+    proxy?: ParsedProxyConfig | false;
+    readReplica?: ParsedReadReplicaConfig | false;
+    credentials?: ParsedCredentialsConfig;
+    writer?: ParsedAuroraWriterConfig;
+    readers?: ParsedAuroraReadersConfig | false;
+    backupRetention?: number;
+    preferredMaintenanceWindow?: string;
+    primaryRegion?: string;
+    secondaryRegions?: string[];
+    globalClusterIdentifier?: string;
+    enableGlobalWriteForwarding?: boolean;
+    allocatedStorage?: number;
+    monitoringInterval?: number;
+    snapshotIdentifier?: string;
+    snapshotUsername?: string;
+    extraProperties?: ExtraProperty[];
+    node: ts.Node;
+}
+declare const DYNAMODB_KEY_TYPES: readonly ["S", "N", "B"];
+type DynamoDBKeyType = (typeof DYNAMODB_KEY_TYPES)[number];
+interface DynamoDBKey {
+    name: string;
+    type: DynamoDBKeyType;
+}
+export interface ParsedDynamoDBResource {
+    variableName?: string;
+    resourceName: string;
+    partitionKey: DynamoDBKey;
+    sortKey?: DynamoDBKey;
+    globalSecondaryIndexes?: Array<{
+        indexName: string;
+        partitionKey: DynamoDBKey;
+        sortKey?: DynamoDBKey;
+    }>;
+    ttlAttribute?: string;
+    stream?: boolean;
+    extraProperties?: ExtraProperty[];
+    node: ts.Node;
+}
+/** Find all database resources (including DynamoDB) from addDatabase calls */
+export declare function findDatabaseResources(sourceFile: ts.SourceFile): ParsedDatabaseResource[];
+/** Split DynamoDB resources (type: "DynamoDB") from regular database resources */
+export declare function splitDynamoDBFromDatabases(allResources: ParsedDatabaseResource[]): {
+    databases: ParsedDatabaseResource[];
+    dynamodb: ParsedDynamoDBResource[];
+};
+/** Convert parsed database resources to plan format */
+export declare function convertDatabaseResources(databaseResources: ParsedDatabaseResource[]): ApplicationResourcePlan["database"];
+/** Convert parsed DynamoDB resources to plan format */
+export declare function convertDynamoDBResources(dynamodbResources: ParsedDynamoDBResource[]): ApplicationResourcePlan["dynamodb"];
+export {};

package/dist/src/ast/astDatabaseParser.js

@@ -0,0 +1,275 @@
+import * as ts from "typescript";
+import { constIncludes } from "../schemas/constants.js";
+import { asBoolean, asNumber, asString, asStringArray, asStringUnion, captureExtraProperties, collectFromAst, extractVariableName, isCallRef, isFactoryBuildCall, isFactoryMethodCall, isParsedObject, omitUndefined, parseObjectLiteral, parseOptionalConfig, parseBooleanOrConfig, resolveTemplateLiteral, typed, } from "./astCommonParser.js";
+const DYNAMODB_KEY_TYPES = ["S", "N", "B"];
+// ---- Extraction helpers ----
+/** Derive database engine from parsed config */
+function extractDatabaseEngine(config) {
+    const directEngine = asString(config.databaseEngine);
+    if (directEngine === "postgresql" || directEngine === "mysql")
+        return directEngine;
+    const engine = config.engine;
+    if (isCallRef(engine)) {
+        const callText = String(engine.__call);
+        if (callText.includes("postgres") || callText.includes("auroraPostgres")) {
+            return "postgresql";
+        }
+        if (callText.includes("mysql") || callText.includes("auroraMysql")) {
+            return "mysql";
+        }
+    }
+    return undefined;
+}
+/** Extract raw engine expression text */
+function extractEngineExpression(config) {
+    const engine = config.engine;
+    if (isCallRef(engine)) {
+        return String(engine.__call);
+    }
+    return undefined;
+}
+const DATABASE_KNOWN_KEYS = new Set([
+    "type",
+    "databaseName",
+    "databaseEngine",
+    "engine",
+    "vpc",
+    "port",
+    "deletionProtection",
+    "instanceType",
+    "multiAz",
+    "publiclyAccessible",
+    "enableSecretRotation",
+    "encryption",
+    "databaseInsights",
+    "proxy",
+    "readReplica",
+    "credentials",
+    "writer",
+    "readers",
+    "backupRetention",
+    "preferredMaintenanceWindow",
+    "primaryRegion",
+    "secondaryRegions",
+    "globalClusterIdentifier",
+    "enableGlobalWriteForwarding",
+    "snapshotIdentifier",
+    "allocatedStorage",
+    "monitoringInterval",
+    "snapshotUsername",
+]);
+function extractDatabaseResource(sourceFile, addDatabaseCall, buildCall) {
+    if (buildCall.arguments.length < 2)
+        return null;
+    const nameArg = buildCall.arguments[0];
+    const configArg = buildCall.arguments[1];
+    if (!ts.isStringLiteral(nameArg) && !ts.isTemplateExpression(nameArg)) {
+        return null;
+    }
+    const resourceName = ts.isStringLiteral(nameArg)
+        ? nameArg.text
+        : resolveTemplateLiteral(sourceFile, nameArg);
+    if (!ts.isObjectLiteralExpression(configArg)) {
+        return null;
+    }
+    const config = parseObjectLiteral(configArg);
+    const resource = {
+        resourceName,
+        type: asString(config.type) ?? "",
+        databaseName: asString(config.databaseName) ?? "",
+        databaseEngine: extractDatabaseEngine(config),
+        engineExpression: extractEngineExpression(config),
+        port: asNumber(config.port),
+        deletionProtection: asBoolean(config.deletionProtection),
+        instanceType: asString(config.instanceType),
+        multiAz: asBoolean(config.multiAz),
+        publiclyAccessible: asBoolean(config.publiclyAccessible),
+        enableSecretRotation: asBoolean(config.enableSecretRotation),
+        encryption: parseOptionalConfig(config.encryption, typed()),
+        databaseInsights: parseBooleanOrConfig(config.databaseInsights, typed()),
+        proxy: parseBooleanOrConfig(config.proxy, typed()),
+        readReplica: parseBooleanOrConfig(config.readReplica, typed()),
+        credentials: parseOptionalConfig(config.credentials, typed()),
+        writer: parseOptionalConfig(config.writer, typed()),
+        readers: parseBooleanOrConfig(config.readers, typed()),
+        backupRetention: asNumber(config.backupRetention),
+        preferredMaintenanceWindow: asString(config.preferredMaintenanceWindow),
+        primaryRegion: asString(config.primaryRegion),
+        secondaryRegions: asStringArray(config.secondaryRegions),
+        globalClusterIdentifier: asString(config.globalClusterIdentifier),
+        enableGlobalWriteForwarding: asBoolean(config.enableGlobalWriteForwarding),
+        allocatedStorage: asNumber(config.allocatedStorage),
+        monitoringInterval: asNumber(config.monitoringInterval),
+        snapshotIdentifier: asString(config.snapshotIdentifier),
+        snapshotUsername: asString(config.snapshotUsername),
+        node: addDatabaseCall,
+    };
+    const varName = extractVariableName(addDatabaseCall);
+    if (varName)
+        resource.variableName = varName;
+    const extras = captureExtraProperties(config, DATABASE_KNOWN_KEYS);
+    if (extras.length > 0)
+        resource.extraProperties = extras;
+    return resource;
+}
+// ---- DynamoDB helpers ----
+/** Parse a DynamoDB key schema from parsed AST object */
+function parseDynamoDBKey(value) {
+    if (!isParsedObject(value))
+        return undefined;
+    const name = asString(value.name);
+    const type = asStringUnion(value.type, DYNAMODB_KEY_TYPES);
+    if (!name || !type)
+        return undefined;
+    return { name, type };
+}
+/** Extract DynamoDB-specific fields from a parsed database resource */
+function extractDynamoDBFields(resource) {
+    const node = resource.node;
+    if (!ts.isCallExpression(node))
+        return null;
+    const buildCallArg = node.arguments[0];
+    if (!ts.isCallExpression(buildCallArg) || buildCallArg.arguments.length < 2)
+        return null;
+    const configArg = buildCallArg.arguments[1];
+    if (!ts.isObjectLiteralExpression(configArg))
+        return null;
+    const config = parseObjectLiteral(configArg);
+    const partitionKey = parseDynamoDBKey(config.partitionKey);
+    if (!partitionKey)
+        return null;
+    const result = {
+        resourceName: resource.resourceName,
+        partitionKey,
+        node: resource.node,
+    };
+    if (resource.variableName)
+        result.variableName = resource.variableName;
+    const sortKey = parseDynamoDBKey(config.sortKey);
+    if (sortKey)
+        result.sortKey = sortKey;
+    if (Array.isArray(config.globalSecondaryIndexes)) {
+        const gsis = config.globalSecondaryIndexes
+            .filter(isParsedObject)
+            .map((gsi) => {
+            const pk = parseDynamoDBKey(gsi.partitionKey);
+            if (!pk)
+                return null;
+            const indexName = asString(gsi.indexName);
+            if (!indexName)
+                return null;
+            const entry = { indexName, partitionKey: pk };
+            const sk = parseDynamoDBKey(gsi.sortKey);
+            if (sk)
+                entry.sortKey = sk;
+            return entry;
+        })
+            .filter((g) => g !== null);
+        if (gsis.length > 0)
+            result.globalSecondaryIndexes = gsis;
+    }
+    const ttlAttribute = asString(config.ttlAttribute);
+    if (ttlAttribute)
+        result.ttlAttribute = ttlAttribute;
+    const stream = asBoolean(config.stream);
+    if (stream !== undefined)
+        result.stream = stream;
+    const DYNAMODB_KNOWN_KEYS = new Set([
+        "type",
+        "databaseName",
+        "partitionKey",
+        "sortKey",
+        "globalSecondaryIndexes",
+        "ttlAttribute",
+        "stream",
+    ]);
+    const extras = captureExtraProperties(config, DYNAMODB_KNOWN_KEYS);
+    if (extras.length > 0)
+        result.extraProperties = extras;
+    return result;
+}
+// ---- Public API ----
+/** Find all database resources (including DynamoDB) from addDatabase calls */
+export function findDatabaseResources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addDatabase"))
+            return null;
+        const databaseArg = node.arguments[0];
+        if (!isFactoryBuildCall(databaseArg, "DatabaseFactory"))
+            return null;
+        return extractDatabaseResource(sourceFile, node, databaseArg);
+    });
+}
+/** Split DynamoDB resources (type: "DynamoDB") from regular database resources */
+export function splitDynamoDBFromDatabases(allResources) {
+    const databases = [];
+    const dynamodb = [];
+    for (const resource of allResources) {
+        if (resource.type === "DynamoDB") {
+            const dynamo = extractDynamoDBFields(resource);
+            if (dynamo)
+                dynamodb.push(dynamo);
+        }
+        else {
+            databases.push(resource);
+        }
+    }
+    return { databases, dynamodb };
+}
+const VALID_DB_TYPES = ["Instance", "Aurora", "GlobalAurora"];
+/** Convert parsed database resources to plan format */
+export function convertDatabaseResources(databaseResources) {
+    return databaseResources
+        .filter((db) => db.type !== "DynamoDB")
+        .map((database) => ({
+        name: database.resourceName,
+        type: constIncludes(VALID_DB_TYPES, database.type)
+            ? database.type
+            : "Instance",
+        databaseName: database.databaseName,
+        ...omitUndefined({
+            port: database.port,
+            deletionProtection: database.deletionProtection,
+            instanceType: database.instanceType,
+            multiAz: database.multiAz,
+            publiclyAccessible: database.publiclyAccessible,
+            enableSecretRotation: database.enableSecretRotation,
+            encryption: database.encryption,
+            databaseInsights: database.databaseInsights,
+            proxy: database.proxy,
+            readReplica: database.readReplica,
+            credentials: database.credentials,
+            writer: database.writer,
+            readers: database.readers,
+            backupRetention: database.backupRetention,
+            preferredMaintenanceWindow: database.preferredMaintenanceWindow,
+            primaryRegion: database.primaryRegion,
+            secondaryRegions: database.secondaryRegions,
+            globalClusterIdentifier: database.globalClusterIdentifier,
+            enableGlobalWriteForwarding: database.enableGlobalWriteForwarding,
+            allocatedStorage: database.allocatedStorage,
+            monitoringInterval: database.monitoringInterval,
+            variableName: database.variableName,
+            databaseEngine: database.databaseEngine,
+            engineExpression: database.engineExpression,
+            extraProperties: database.extraProperties,
+        }),
+    }));
+}
+/** Convert parsed DynamoDB resources to plan format */
+export function convertDynamoDBResources(dynamodbResources) {
+    if (dynamodbResources.length === 0)
+        return undefined;
+    return dynamodbResources.map((table) => ({
+        name: table.resourceName,
+        partitionKey: table.partitionKey,
+        ...omitUndefined({
+            sortKey: table.sortKey,
+            globalSecondaryIndexes: table.globalSecondaryIndexes,
+            ttlAttribute: table.ttlAttribute,
+            stream: table.stream,
+            variableName: table.variableName,
+            extraProperties: table.extraProperties,
+        }),
+    }));
+}