@fjall/generator 0.88.4

package/dist/src/types/Result.d.ts

@@ -0,0 +1,19 @@
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};
+export declare function isSuccess<T, E>(result: Result<T, E>): result is {
+    success: true;
+    data: T;
+};
+export declare function isFailure<T, E>(result: Result<T, E>): result is {
+    success: false;
+    error: E;
+};
+export declare function success<T>(data: T): Result<T, never>;
+export declare function failure<E>(error: E): Result<never, E>;
+export declare function tryAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+export declare function trySync<T>(fn: () => T): Result<T, Error>;

package/dist/src/types/Result.js

@@ -0,0 +1,31 @@
+import { normaliseError } from "../util/errorUtils.js";
+export function isSuccess(result) {
+    return result.success === true;
+}
+export function isFailure(result) {
+    return result.success === false;
+}
+export function success(data) {
+    return { success: true, data };
+}
+export function failure(error) {
+    return { success: false, error };
+}
+export async function tryAsync(fn) {
+    try {
+        const data = await fn();
+        return success(data);
+    }
+    catch (error) {
+        return failure(normaliseError(error));
+    }
+}
+export function trySync(fn) {
+    try {
+        const data = fn();
+        return success(data);
+    }
+    catch (error) {
+        return failure(normaliseError(error));
+    }
+}

package/dist/src/util/errorUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function normaliseError(error: unknown): Error;
+export declare function getErrorMessage(error: unknown): string;

package/dist/src/util/errorUtils.js

@@ -0,0 +1,15 @@
+export function normaliseError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error && typeof error === "object" && "message" in error) {
+        return String(error.message);
+    }
+    return "An unknown error occurred";
+}

package/dist/src/validation/patterns.d.ts

@@ -0,0 +1,300 @@
+export declare const VALIDATION_PATTERNS: Readonly<{
+    readonly IDENTIFIER: RegExp;
+    readonly RESOURCE_NAME: RegExp;
+    readonly ECS_SERVICE_NAME: RegExp;
+    readonly BUCKET_NAME: RegExp;
+    readonly DATABASE_NAME: RegExp;
+    readonly RESOURCE_TYPE: RegExp;
+    readonly SSM_PATH: RegExp;
+    readonly SECRET_NAME: RegExp;
+    readonly SSM_COMPONENT: RegExp;
+    readonly EMAIL: RegExp;
+    readonly DOCKER_IMAGE: RegExp;
+    readonly DOMAIN: RegExp;
+}>;
+export declare const VALIDATION_MESSAGES: Readonly<{
+    readonly IDENTIFIER: "Must start with a letter, contain only letters, numbers, and hyphens";
+    readonly IDENTIFIER_MIN_LENGTH: "Must be at least 2 characters";
+    readonly IDENTIFIER_NO_TRAILING_HYPHEN: "Must not end with a hyphen";
+    readonly IDENTIFIER_NO_CONSECUTIVE_HYPHENS: "Must not contain consecutive hyphens";
+    readonly RESOURCE_NAME: "Must start with a letter and contain only letters and numbers (PascalCase recommended)";
+    readonly ECS_SERVICE_NAME: "Service name must start with a letter and contain only letters, numbers, and hyphens";
+    readonly BUCKET_NAME: "Bucket name must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens";
+    readonly DATABASE_NAME: "Database name must start with a letter and contain only letters, numbers, and underscores";
+    readonly RESOURCE_TYPE: "Resource type must be in format 'category' or 'category:type'";
+    readonly SSM_PATH: "SSM path must start with / and contain valid namespace segments (e.g., /myapp/ApiCluster/service)";
+    readonly SECRET_NAME: "Secret name must start with a letter or underscore and contain only letters, numbers, underscores, hyphens, or periods";
+    readonly SSM_COMPONENT: "Must start with a letter and contain only letters, numbers, periods, hyphens, or underscores";
+    readonly EMAIL: "Please enter a valid email address";
+    readonly DOMAIN: "Please enter a valid domain (e.g., cms.example.com)";
+    readonly DOCKER_IMAGE: "Invalid Docker image name format";
+    readonly REQUIRED: {
+        readonly APP_NAME: "Application name is required";
+        readonly RESOURCE_NAME: "Resource name is required";
+        readonly BUCKET_NAME: "Bucket name is required";
+        readonly SERVICE_NAME: "Service name is required";
+        readonly NETWORK_NAME: "Network name is required";
+        readonly DATABASE_NAME: "Database name is required";
+        readonly ORGANISATION_NAME: "Organisation name is required";
+        readonly EMAIL: "Email is required";
+        readonly NAME: "Name is required";
+        readonly USERNAME: "Username is required";
+        readonly CONTAINER_NAME: "Container name is required";
+        readonly FIRST_NAME: "First name is required";
+        readonly LAST_NAME: "Last name is required";
+        readonly GROUP: "Group is required";
+        readonly PATTERN_NAME: "Pattern name is required";
+        readonly ROUTING_PATH: "Routing path is required";
+        readonly RESOURCE_TYPE: "Resource type is required";
+        readonly VARIANT: "Variant is required";
+        readonly SUBTYPE: "Subtype is required";
+        readonly DEPLOY_TARGET: "Deploy target is required";
+        readonly DESTROY_TARGET: "Destroy target is required";
+    };
+    readonly MAX_LENGTH: {
+        readonly APP_NAME: "Application name must be 50 characters or less";
+        readonly RESOURCE_NAME: "Resource name must be 63 characters or less";
+        readonly BUCKET_NAME: "Bucket name must be 63 characters or less";
+        readonly SERVICE_NAME: "Service name must be 255 characters or less";
+        readonly NETWORK_NAME: "Network name must be 50 characters or less";
+        readonly DATABASE_NAME: "Database name must be 63 characters or less";
+        readonly ORGANISATION_NAME: "Organisation name must be 50 characters or less";
+    };
+    readonly PORT: {
+        readonly INTEGER: "Port must be an integer";
+        readonly MIN: "Port must be at least 1";
+        readonly MAX: "Port cannot exceed 65535";
+    };
+    readonly USERNAME: {
+        readonly MAX_LENGTH: "Username cannot exceed 63 characters";
+    };
+    readonly LAMBDA: {
+        readonly MEMORY: {
+            readonly INTEGER: "Lambda memory must be an integer";
+            readonly MIN: "Memory must be at least 128 MB";
+            readonly MAX: "Memory cannot exceed 10240 MB";
+            readonly MULTIPLE: "Memory must be 128 MB or a multiple of 64 MB";
+        };
+        readonly TIMEOUT: {
+            readonly INTEGER: "Timeout must be an integer";
+            readonly MIN: "Timeout must be at least 1 second";
+            readonly MAX: "Timeout cannot exceed 900 seconds";
+        };
+    };
+    readonly PRIORITY: {
+        readonly INTEGER: "Priority must be an integer";
+        readonly MIN: "Priority must be at least 1";
+        readonly MAX: "Priority cannot exceed 50000";
+    };
+    readonly CAPACITY: {
+        readonly MIN: {
+            readonly INTEGER: "Minimum capacity must be an integer";
+            readonly MIN_0: "Minimum capacity must be at least 0";
+            readonly MIN_1: "Minimum capacity must be at least 1";
+            readonly MAX: "Minimum capacity cannot exceed 100";
+        };
+        readonly MAX: {
+            readonly INTEGER: "Maximum capacity must be an integer";
+            readonly MIN_0: "Maximum capacity must be at least 0";
+            readonly MIN_1: "Maximum capacity must be at least 1";
+            readonly MAX: "Maximum capacity cannot exceed 100";
+        };
+        readonly DESIRED: {
+            readonly INTEGER: "Desired count must be an integer";
+            readonly MIN: "Desired count must be at least 0";
+            readonly MAX: "Desired count cannot exceed 100";
+        };
+    };
+    readonly MEMORY_LIMIT: {
+        readonly INTEGER: "Memory limit must be an integer";
+        readonly MIN_512: "Memory limit must be at least 512 MiB";
+        readonly MIN_128: "Memory limit must be at least 128 MiB";
+        readonly MAX: "Memory limit cannot exceed 30720 MiB";
+    };
+    readonly DATABASE: {
+        readonly PORT: {
+            readonly INTEGER: "Database port must be an integer";
+            readonly MIN: "Database port must be at least 1024";
+            readonly MAX: "Database port cannot exceed 65535";
+        };
+        readonly NAME: {
+            readonly REQUIRED: "Database name is required";
+            readonly MAX_LENGTH: "Database name cannot exceed 64 characters";
+        };
+    };
+    readonly BACKUP_RETENTION: {
+        readonly INTEGER: "Backup retention must be an integer";
+        readonly MIN: "Backup retention must be at least 1 day";
+        readonly MAX: "Backup retention cannot exceed 35 days";
+    };
+    readonly SQS: {
+        readonly VISIBILITY_TIMEOUT: {
+            readonly INTEGER: "Visibility timeout must be an integer";
+            readonly MIN: "Visibility timeout must be at least 0 seconds";
+            readonly MAX: "Visibility timeout cannot exceed 43200 seconds (12 hours)";
+        };
+        readonly RETENTION_PERIOD: {
+            readonly INTEGER: "Retention period must be an integer";
+            readonly MIN: "Retention period must be at least 60 seconds";
+            readonly MAX: "Retention period cannot exceed 1209600 seconds (14 days)";
+        };
+    };
+    readonly READER: {
+        readonly COUNT: {
+            readonly INTEGER: "Reader count must be an integer";
+            readonly MIN: "Reader count must be at least 0";
+            readonly MAX: "Reader count cannot exceed 15";
+        };
+    };
+    readonly IDENTIFIER_SUFFIX: {
+        readonly REQUIRED: "Identifier suffix is required when specified";
+        readonly MAX_LENGTH: "Identifier suffix cannot exceed 50 characters";
+    };
+    readonly ROTATION: {
+        readonly INTEGER: "Rotation days must be an integer";
+        readonly MIN: "Rotation interval must be at least 1 day";
+        readonly MAX: "Rotation interval cannot exceed 365 days";
+    };
+    readonly MAX_CONNECTIONS: {
+        readonly INTEGER: "Max connections must be an integer";
+        readonly MIN: "Max connections must be at least 1";
+        readonly MAX: "Max connections cannot exceed 100";
+    };
+    readonly MONITORING_INTERVAL: {
+        readonly INTEGER: "Monitoring interval must be an integer";
+        readonly MIN: "Monitoring interval must be at least 0";
+        readonly MAX: "Monitoring interval cannot exceed 60 seconds";
+        readonly VALUES: "Monitoring interval must be 0, 1, 5, 10, 15, 30, or 60 seconds";
+    };
+    readonly RETENTION_DAYS: {
+        readonly INTEGER: "Retention days must be an integer";
+        readonly MIN: "Retention days must be at least 1";
+        readonly MAX: "Retention days cannot exceed 365";
+    };
+    readonly BATCH_SIZE: {
+        readonly INTEGER: "Batch size must be an integer";
+        readonly MIN: "Batch size must be at least 1";
+        readonly MAX: "Batch size cannot exceed 10000";
+    };
+    readonly SERVICE: {
+        readonly UNIQUE_WITHIN_CLUSTER: "Service names must be unique within a cluster";
+        readonly MIN_REQUIRED: "At least one service is required";
+        readonly ROUTING_REQUIRED: "Multiple services with ports require routing config (path or host)";
+    };
+    readonly PROXY_CONFIG: {
+        readonly MAX_IDLE_CONNECTIONS: {
+            readonly INTEGER: "Max idle connections must be an integer";
+            readonly MIN: "Max idle connections must be at least 0";
+            readonly MAX: "Max idle connections cannot exceed 100";
+        };
+        readonly BORROW_TIMEOUT: {
+            readonly INTEGER: "Connection borrow timeout must be an integer";
+            readonly MIN: "Connection borrow timeout must be at least 1 second";
+            readonly MAX: "Connection borrow timeout cannot exceed 3600 seconds";
+        };
+    };
+    readonly MAX_AZS: {
+        readonly INTEGER: "Max AZs must be an integer";
+        readonly MIN: "Max AZs must be at least 1";
+        readonly MAX: "Max AZs cannot exceed 3";
+    };
+    readonly BATCHING_WINDOW: {
+        readonly INTEGER: "Max batching window must be an integer";
+        readonly MIN: "Max batching window must be at least 0";
+        readonly MAX: "Max batching window cannot exceed 300 seconds";
+    };
+    readonly HEALTH_CHECK: {
+        readonly INTERVAL: {
+            readonly INTEGER: "Health check interval must be an integer";
+            readonly MIN: "Health check interval must be at least 5 seconds";
+            readonly MAX: "Health check interval cannot exceed 300 seconds";
+        };
+        readonly TIMEOUT: {
+            readonly INTEGER: "Health check timeout must be an integer";
+            readonly MIN: "Health check timeout must be at least 2 seconds";
+            readonly MAX: "Health check timeout cannot exceed 60 seconds";
+        };
+        readonly RETRIES: {
+            readonly INTEGER: "Health check retries must be an integer";
+            readonly MIN: "Health check retries must be at least 1";
+            readonly MAX: "Health check retries cannot exceed 10";
+        };
+        readonly START_PERIOD: {
+            readonly INTEGER: "Health check start period must be an integer";
+            readonly MIN: "Health check start period must be at least 0 seconds";
+            readonly MAX: "Health check start period cannot exceed 300 seconds";
+        };
+    };
+    readonly EPHEMERAL_STORAGE: {
+        readonly INTEGER: "Ephemeral storage size must be an integer";
+        readonly MIN: "Ephemeral storage size must be at least 512 MB";
+        readonly MAX: "Ephemeral storage size cannot exceed 10240 MB";
+    };
+    readonly MAX_MESSAGE_SIZE: {
+        readonly INTEGER: "Max message size must be an integer";
+        readonly MIN: "Max message size must be at least 1024 bytes";
+        readonly MAX: "Max message size cannot exceed 262144 bytes (256 KB)";
+    };
+    readonly CAPACITY_CONSTRAINT: {
+        readonly MIN_LTE_MAX: "minCapacity must be less than or equal to maxCapacity";
+    };
+    readonly DIRECT_ACCESS: {
+        readonly NO_DOMAIN: "directAccess cannot be used with domain (no ALB for HTTPS)";
+        readonly NO_LOAD_BALANCER: "directAccess cannot be used with loadBalancer (mutually exclusive)";
+    };
+    readonly GLOBAL_AURORA: {
+        readonly PRIMARY_REGION_REQUIRED: "primaryRegion is required for GlobalAurora databases";
+    };
+    readonly NAT_GATEWAY: {
+        readonly INTEGER: "NAT gateway count must be an integer";
+        readonly MIN: "NAT gateway count must be at least 0";
+        readonly MAX: "NAT gateway count cannot exceed 3";
+    };
+    readonly CIDR_MASK: {
+        readonly INTEGER: "CIDR mask must be an integer";
+        readonly MIN: "CIDR mask must be at least 16";
+        readonly MAX: "CIDR mask cannot exceed 28";
+    };
+    readonly CPU: {
+        readonly INTEGER: "CPU must be an integer";
+        readonly MIN: "CPU must be at least 256 units";
+        readonly MAX: "CPU cannot exceed 4096 units";
+    };
+    readonly KMS: {
+        readonly KEY_REQUIRED: "KMS key ARN is required when using KMS encryption";
+    };
+    readonly WEBSITE_BUCKET: {
+        readonly DOCUMENTS_REQUIRED: "Website index and error documents are required for website buckets";
+    };
+    readonly READER_INSTANCES: {
+        readonly MAX: "Cannot have more than 15 reader instances";
+        readonly COUNT_OR_INSTANCES: "Cannot specify both 'count' and 'instances' - use one or the other";
+    };
+    readonly GENERATOR_CAPACITY: {
+        readonly MIN: {
+            readonly MIN: "Minimum capacity must be at least 1";
+            readonly MAX: "Minimum capacity cannot exceed 1000";
+        };
+        readonly MAX: {
+            readonly MIN: "Maximum capacity must be at least 1";
+            readonly MAX: "Maximum capacity cannot exceed 1000";
+        };
+    };
+    readonly INSTANCE_TYPE: "Unknown instance type. Common types include: t4g.micro, t4g.small, m5.large";
+    readonly ARCHITECTURE_MISMATCH: "Architecture mismatch between instance type and AMI";
+    readonly ALLOCATED_STORAGE: {
+        readonly INTEGER: "Allocated storage must be an integer";
+        readonly MIN: "Allocated storage must be at least 20 GB";
+        readonly MAX: "Allocated storage cannot exceed 65536 GB";
+    };
+    readonly DLQ: {
+        readonly MAX_RECEIVE_COUNT: {
+            readonly INTEGER: "Max receive count must be an integer";
+            readonly MIN: "Max receive count must be at least 1";
+            readonly MAX: "Max receive count cannot exceed 1000";
+        };
+    };
+    readonly REGION: "Invalid AWS region";
+}>;
+export type ValidationPatternKey = keyof typeof VALIDATION_PATTERNS;
+export type ValidationMessageKey = keyof typeof VALIDATION_MESSAGES;