@fjall/generator 0.88.4

package/dist/src/aws/regions.js

@@ -0,0 +1,254 @@
+export const DEFAULT_REGION = "us-east-2";
+export const regions = Object.freeze([
+    "us-east-2",
+    "us-west-2",
+    "us-east-1",
+    "eu-west-1",
+    "eu-central-1",
+    "ap-southeast-1",
+    "ap-northeast-1",
+    "ap-southeast-2",
+    "us-west-1",
+    "ca-central-1",
+    "af-south-1",
+    "ap-east-1",
+    "ap-northeast-2",
+    "ap-northeast-3",
+    "ap-south-1",
+    "ap-south-2",
+    "ap-southeast-3",
+    "ap-southeast-4",
+    "eu-central-2",
+    "eu-north-1",
+    "eu-south-1",
+    "eu-south-2",
+    "eu-west-2",
+    "eu-west-3",
+    "me-central-1",
+    "me-south-1",
+    "sa-east-1",
+]);
+export const AWS_REGIONS_METADATA = Object.freeze([
+    { code: "us-east-2", name: "US East", city: "Ohio", country: "USA" },
+    { code: "us-west-2", name: "US West", city: "Oregon", country: "USA" },
+    { code: "us-east-1", name: "US East", city: "N. Virginia", country: "USA" },
+    { code: "eu-west-1", name: "EU West", city: "Ireland", country: "Ireland" },
+    {
+        code: "eu-central-1",
+        name: "EU Central",
+        city: "Frankfurt",
+        country: "Germany",
+    },
+    {
+        code: "ap-southeast-1",
+        name: "Asia Pacific",
+        city: "Singapore",
+        country: "Singapore",
+    },
+    {
+        code: "ap-northeast-1",
+        name: "Asia Pacific",
+        city: "Tokyo",
+        country: "Japan",
+    },
+    {
+        code: "ap-southeast-2",
+        name: "Asia Pacific",
+        city: "Sydney",
+        country: "Australia",
+    },
+    { code: "us-west-1", name: "US West", city: "N. California", country: "USA" },
+    { code: "ca-central-1", name: "Canada", city: "Central", country: "Canada" },
+    {
+        code: "af-south-1",
+        name: "Africa",
+        city: "Cape Town",
+        country: "South Africa",
+    },
+    {
+        code: "ap-east-1",
+        name: "Asia Pacific",
+        city: "Hong Kong",
+        country: "China",
+    },
+    {
+        code: "ap-northeast-2",
+        name: "Asia Pacific",
+        city: "Seoul",
+        country: "South Korea",
+    },
+    {
+        code: "ap-northeast-3",
+        name: "Asia Pacific",
+        city: "Osaka",
+        country: "Japan",
+    },
+    {
+        code: "ap-south-1",
+        name: "Asia Pacific",
+        city: "Mumbai",
+        country: "India",
+    },
+    {
+        code: "ap-south-2",
+        name: "Asia Pacific",
+        city: "Hyderabad",
+        country: "India",
+    },
+    {
+        code: "ap-southeast-3",
+        name: "Asia Pacific",
+        city: "Jakarta",
+        country: "Indonesia",
+    },
+    {
+        code: "ap-southeast-4",
+        name: "Asia Pacific",
+        city: "Melbourne",
+        country: "Australia",
+    },
+    {
+        code: "eu-central-2",
+        name: "EU Central",
+        city: "Zurich",
+        country: "Switzerland",
+    },
+    {
+        code: "eu-north-1",
+        name: "EU North",
+        city: "Stockholm",
+        country: "Sweden",
+    },
+    { code: "eu-south-1", name: "EU South", city: "Milan", country: "Italy" },
+    { code: "eu-south-2", name: "EU South", city: "Spain", country: "Spain" },
+    { code: "eu-west-2", name: "EU West", city: "London", country: "UK" },
+    { code: "eu-west-3", name: "EU West", city: "Paris", country: "France" },
+    { code: "me-central-1", name: "Middle East", city: "UAE", country: "UAE" },
+    {
+        code: "me-south-1",
+        name: "Middle East",
+        city: "Bahrain",
+        country: "Bahrain",
+    },
+    {
+        code: "sa-east-1",
+        name: "South America",
+        city: "S\u00e3o Paulo",
+        country: "Brazil",
+    },
+]);
+export const topRegions = Object.freeze([
+    { code: "us-east-2", name: "US East", city: "Ohio", country: "USA" },
+    { code: "us-west-2", name: "US West", city: "Oregon", country: "USA" },
+    { code: "us-east-1", name: "US East", city: "N. Virginia", country: "USA" },
+    { code: "eu-west-1", name: "EU West", city: "Ireland", country: "Ireland" },
+    {
+        code: "eu-central-1",
+        name: "EU Central",
+        city: "Frankfurt",
+        country: "Germany",
+    },
+    {
+        code: "ap-southeast-1",
+        name: "Asia Pacific",
+        city: "Singapore",
+        country: "Singapore",
+    },
+]);
+export const commonRegions = Object.freeze([
+    "us-east-2",
+    "us-west-2",
+    "us-east-1",
+    "eu-west-1",
+    "ap-southeast-1",
+]);
+export function parseRegionList(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((region) => region.trim())
+        .filter(Boolean);
+}
+export function isValidRegion(region) {
+    return regions.includes(region);
+}
+export function isValidRegionFormat(region) {
+    // AWS region format pattern
+    const regionRegex = /^[a-z]{2}-[a-z]+-[1-9]$/;
+    return regionRegex.test(region);
+}
+export function getSuggestions(input) {
+    // Return common regions if input is empty
+    if (!input) {
+        return commonRegions.slice(0, 3);
+    }
+    // Get prefix and direction from input
+    const parts = input.toLowerCase().split("-");
+    const prefix = parts[0];
+    const direction = parts.length > 1 ? parts[1] : "";
+    // First try to match both prefix and direction
+    let matches = [];
+    if (prefix && direction) {
+        matches = regions.filter((region) => region.startsWith(`${prefix}-${direction}`));
+    }
+    // If no matches, try just the prefix
+    if (matches.length === 0 && prefix) {
+        matches = regions.filter((region) => region.startsWith(`${prefix}-`));
+    }
+    // If still no matches, return common regions
+    return matches.length > 0 ? matches.slice(0, 3) : commonRegions.slice(0, 3);
+}
+export function validateRegion(region) {
+    // Check if the region is valid
+    if (isValidRegion(region)) {
+        return true;
+    }
+    // Get suggestions for invalid region
+    const suggestions = getSuggestions(region);
+    // If format is invalid, return format error
+    if (!isValidRegionFormat(region)) {
+        return `Invalid format. Try: ${suggestions.join(", ")}`;
+    }
+    // If format is valid but region not recognized
+    return `Unknown region. Try: ${suggestions.join(", ")}`;
+}
+export function validateRegionList(value) {
+    if (!value || value.trim() === "")
+        return true;
+    const regionsList = parseRegionList(value);
+    for (const region of regionsList) {
+        const regionValidation = validateRegion(region);
+        if (regionValidation !== true) {
+            return regionValidation;
+        }
+    }
+    return true;
+}
+export function filterDuplicateRegions(regions, primaryRegion) {
+    return regions.filter((region) => region !== primaryRegion);
+}
+export function getRegionOptions() {
+    return AWS_REGIONS_METADATA.map((region) => ({
+        label: region.city,
+        value: region.code,
+        description: region.code,
+    }));
+}
+export function getRegionOptionsExcluding(excludeCode) {
+    return AWS_REGIONS_METADATA.filter((region) => region.code !== excludeCode).map((region) => ({
+        label: region.city,
+        value: region.code,
+        description: region.code,
+    }));
+}
+export function getRegionName(code) {
+    const region = AWS_REGIONS_METADATA.find((r) => r.code === code);
+    return region ? region.city : code;
+}
+export function createRegionFormatter(primaryRegion) {
+    return (value) => {
+        const secondaryRegions = parseRegionList(value);
+        return filterDuplicateRegions(secondaryRegions, primaryRegion);
+    };
+}

package/dist/src/generation/common.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Common Utilities for Code Generation
+ *
+ * Shared helper functions used across all generation modules.
+ */
+import type { IdentifierValue, ExpressionValue, CallValue, SpecialValue } from "../schemas/resourceSchemas.js";
+export type { IdentifierValue, ExpressionValue, CallValue, SpecialValue };
+/**
+ * Type guard to check if a value is a special code generation value
+ */
+export declare function isSpecialValue(value: unknown): value is SpecialValue;
+/**
+ * Convert hyphenated/underscored names to PascalCase for resource names
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Convert any case (PascalCase, camelCase, kebab-case, snake_case) to kebab-case.
+ * Three-pass regex: split acronyms, split camel boundaries, replace separators.
+ * e.g., "MyApp" -> "my-app", "AWSLambda" -> "aws-lambda", "myApp" -> "my-app"
+ */
+export declare function toKebab(str: string): string;
+/**
+ * Convert a name to a valid RDS database name (snake_case).
+ * RDS API allows letters, numbers, and underscores for PostgreSQL/MySQL DatabaseName.
+ * Hyphens are rejected, so convert them to underscores.
+ */
+export declare function toValidDatabaseName(name: string): string;
+/**
+ * Convert resource names to camelCase variable names
+ */
+export declare function toVariableName(name: string): string;
+/**
+ * Get the variable name for a resource, preferring preserved variableName
+ * from round-trip parsing over the generated default.
+ */
+export declare function getVariableName(resource: {
+    name: string;
+    variableName?: string;
+}): string;
+/**
+ * Resolve the variable name for a resource by name, looking up across all
+ * resource arrays in the plan. Used for cross-resource references (e.g.,
+ * compute → database connection variable names).
+ */
+export declare function resolveResourceVariable(plan: {
+    database: Array<{
+        name: string;
+        variableName?: string;
+    }>;
+    s3: Array<{
+        name: string;
+        variableName?: string;
+    }>;
+    compute: Array<{
+        name: string;
+        variableName?: string;
+    }>;
+    dynamodb?: Array<{
+        name: string;
+        variableName?: string;
+    }>;
+    sqs?: Array<{
+        name: string;
+        variableName?: string;
+    }>;
+}, resourceName: string): string;
+/**
+ * Format values for code generation, handling complex types.
+ * Simple objects (few primitive values) are kept on one line.
+ */
+export declare function formatValue(value: unknown, baseIndent?: string): string;
+type PropertyFormat = "raw" | "string" | "object" | "boolean-or-object";
+/**
+ * Build a property string for code generation.
+ * Handles different value formats: raw (numbers/booleans), string (quoted),
+ * object (using formatValue), and boolean-or-object (special false handling).
+ */
+export declare function buildProperty(condition: boolean, name: string, value: unknown, format?: PropertyFormat): string;
+/**
+ * Emit extra properties preserved verbatim during round-trip.
+ * Each property is emitted as `key: sourceText,` at the given indentation.
+ */
+export declare function emitExtraProperties(extraProperties: Array<{
+    key: string;
+    sourceText: string;
+}> | undefined, indent?: string): string;

package/dist/src/generation/common.js

@@ -0,0 +1,187 @@
+/**
+ * Common Utilities for Code Generation
+ *
+ * Shared helper functions used across all generation modules.
+ */
+/**
+ * Type guard to check if a value is a special code generation value
+ */
+export function isSpecialValue(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const obj = value;
+    return (typeof obj.__identifier === "string" ||
+        typeof obj.__expression === "string" ||
+        typeof obj.__call === "string");
+}
+/**
+ * Convert hyphenated/underscored names to PascalCase for resource names
+ */
+export function toPascalCase(str) {
+    return str
+        .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+        .replace(/^./, (c) => c.toUpperCase());
+}
+/**
+ * Convert any case (PascalCase, camelCase, kebab-case, snake_case) to kebab-case.
+ * Three-pass regex: split acronyms, split camel boundaries, replace separators.
+ * e.g., "MyApp" -> "my-app", "AWSLambda" -> "aws-lambda", "myApp" -> "my-app"
+ */
+export function toKebab(str) {
+    return str
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .replace(/([a-z\d])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+}
+/**
+ * Convert a name to a valid RDS database name (snake_case).
+ * RDS API allows letters, numbers, and underscores for PostgreSQL/MySQL DatabaseName.
+ * Hyphens are rejected, so convert them to underscores.
+ */
+export function toValidDatabaseName(name) {
+    return toKebab(name).replace(/-/g, "_");
+}
+/**
+ * Convert resource names to camelCase variable names
+ */
+export function toVariableName(name) {
+    return name
+        .replace(/[^a-zA-Z0-9]/g, " ")
+        .split(" ")
+        .map((word, index) => index === 0
+        ? word.charAt(0).toLowerCase() + word.slice(1)
+        : word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
+}
+/**
+ * Get the variable name for a resource, preferring preserved variableName
+ * from round-trip parsing over the generated default.
+ */
+export function getVariableName(resource) {
+    return resource.variableName ?? toVariableName(resource.name);
+}
+/**
+ * Resolve the variable name for a resource by name, looking up across all
+ * resource arrays in the plan. Used for cross-resource references (e.g.,
+ * compute → database connection variable names).
+ */
+export function resolveResourceVariable(plan, resourceName) {
+    for (const db of plan.database) {
+        if (db.name === resourceName && db.variableName)
+            return db.variableName;
+    }
+    for (const s3 of plan.s3) {
+        if (s3.name === resourceName && s3.variableName)
+            return s3.variableName;
+    }
+    for (const c of plan.compute) {
+        if (c.name === resourceName && c.variableName)
+            return c.variableName;
+    }
+    for (const ddb of plan.dynamodb ?? []) {
+        if (ddb.name === resourceName && ddb.variableName)
+            return ddb.variableName;
+    }
+    for (const sqs of plan.sqs ?? []) {
+        if (sqs.name === resourceName && sqs.variableName)
+            return sqs.variableName;
+    }
+    return toVariableName(resourceName);
+}
+/**
+ * Check if an object is simple enough to format inline (single line).
+ * Simple = no nested objects/arrays and few primitive values.
+ */
+function isSimpleObject(value) {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return true;
+    if (entries.length > 1)
+        return false;
+    return entries.every(([, v]) => typeof v === "string" ||
+        typeof v === "number" ||
+        typeof v === "boolean" ||
+        v === null);
+}
+/**
+ * Format values for code generation, handling complex types.
+ * Simple objects (few primitive values) are kept on one line.
+ */
+export function formatValue(value, baseIndent = "    ") {
+    if (value === undefined || value === null) {
+        return "undefined";
+    }
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (isSpecialValue(value)) {
+        if ("__identifier" in value)
+            return value.__identifier;
+        if ("__expression" in value)
+            return value.__expression;
+        if ("__call" in value)
+            return value.__call;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => formatValue(v, baseIndent)).join(", ")}]`;
+    }
+    if (typeof value === "object") {
+        // Filter out undefined values — prevents emitting `key: undefined` in generated code
+        const definedEntries = Object.entries(value).filter(([, v]) => v !== undefined);
+        // Simple objects stay on one line
+        if (isSimpleObject(value)) {
+            const formatted = definedEntries
+                .map(([k, v]) => `${k}: ${formatValue(v, baseIndent)}`)
+                .join(", ");
+            return formatted ? `{ ${formatted} }` : "{}";
+        }
+        // Complex objects get multi-line formatting
+        const innerIndent = baseIndent + "  ";
+        const formatted = definedEntries
+            .map(([k, v]) => `${innerIndent}${k}: ${formatValue(v, innerIndent)}`)
+            .join(",\n");
+        return formatted ? `{\n${formatted}\n${baseIndent}}` : "{}";
+    }
+    return JSON.stringify(value);
+}
+/**
+ * Build a property string for code generation.
+ * Handles different value formats: raw (numbers/booleans), string (quoted),
+ * object (using formatValue), and boolean-or-object (special false handling).
+ */
+export function buildProperty(condition, name, value, format = "raw") {
+    if (!condition)
+        return "";
+    let formattedValue;
+    switch (format) {
+        case "string":
+            formattedValue = `"${value}"`;
+            break;
+        case "object":
+            formattedValue = formatValue(value);
+            break;
+        case "boolean-or-object":
+            formattedValue = value === false ? "false" : formatValue(value);
+            break;
+        default:
+            formattedValue = String(value);
+    }
+    return `
+    ${name}: ${formattedValue},`;
+}
+/**
+ * Emit extra properties preserved verbatim during round-trip.
+ * Each property is emitted as `key: sourceText,` at the given indentation.
+ */
+export function emitExtraProperties(extraProperties, indent = "    ") {
+    if (!extraProperties?.length)
+        return "";
+    return extraProperties
+        .map((prop) => `\n${indent}${prop.key}: ${prop.sourceText},`)
+        .join("");
+}

package/dist/src/generation/compute.d.ts

@@ -0,0 +1,6 @@
+import type { ApplicationResourcePlan, ComputeResourcePlan } from "../schemas/resourceSchemas.js";
+export declare function generateLambdaCode(compute: ComputeResourcePlan, _plan: ApplicationResourcePlan): string;
+export declare function generateLambdaConnectionsCode(compute: ComputeResourcePlan, plan: ApplicationResourcePlan): string;
+export declare function generateEc2Code(compute: ComputeResourcePlan): string;
+export declare function generateEcsCode(compute: ComputeResourcePlan, plan: ApplicationResourcePlan): string;
+export declare function generateComputeCode(plan: ApplicationResourcePlan, cdnReferencedResources: Set<string>): string;