@fjall/generator 0.88.4 → 0.89.2

package/dist/src/schemas/storageSchemas.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+/**
+ * Stack placement options for S3 buckets.
+ * - "storage" (default): Created via app.addStorage() in Storage stack
+ * - "cdn": Created in CDN stack for CloudFront-consumed buckets (avoids circular dependencies)
+ * - "compute": Created in Compute stack for Lambda-consumed buckets
+ */
+export declare const S3_STACK_PLACEMENTS: readonly ["storage", "cdn", "compute"];
+export declare const S3ResourcePlanSchema: z.ZodObject<{
+    name: z.ZodString;
+    bucketName: z.ZodOptional<z.ZodString>;
+    publicReadAccess: z.ZodOptional<z.ZodBoolean>;
+    websiteHosting: z.ZodOptional<z.ZodObject<{
+        indexDocument: z.ZodString;
+        errorDocument: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    backupVaultTier: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        resilient: "resilient";
+        enterprise: "enterprise";
+    }>>;
+    versioned: z.ZodOptional<z.ZodBoolean>;
+    encryption: z.ZodOptional<z.ZodEnum<{
+        KMS: "KMS";
+        AES256: "AES256";
+    }>>;
+    kmsKeyArn: z.ZodOptional<z.ZodString>;
+    cors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        allowedOrigins: z.ZodArray<z.ZodString>;
+        allowedMethods: z.ZodArray<z.ZodString>;
+        allowedHeaders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exposedHeaders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxAge: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    deployment: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        prune: z.ZodOptional<z.ZodBoolean>;
+        cacheControl: z.ZodOptional<z.ZodObject<{
+            maxAge: z.ZodOptional<z.ZodNumber>;
+            immutable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    stackPlacement: z.ZodOptional<z.ZodEnum<{
+        storage: "storage";
+        compute: "compute";
+        cdn: "cdn";
+    }>>;
+    variableName: z.ZodOptional<z.ZodString>;
+    extraProperties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        sourceText: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const S3GeneratorSchema: z.ZodObject<{
+    appName: z.ZodString;
+    bucketName: z.ZodString;
+    nameProvidedByFlag: z.ZodOptional<z.ZodBoolean>;
+    storagePreset: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        assets: "assets";
+        upload: "upload";
+        website: "website";
+    }>>;
+    publicReadAccess: z.ZodOptional<z.ZodBoolean>;
+    websiteHosting: z.ZodOptional<z.ZodObject<{
+        indexDocument: z.ZodString;
+        errorDocument: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    backupVaultTier: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        resilient: "resilient";
+        enterprise: "enterprise";
+    }>>;
+    versioned: z.ZodOptional<z.ZodBoolean>;
+    encryption: z.ZodOptional<z.ZodEnum<{
+        KMS: "KMS";
+        AES256: "AES256";
+    }>>;
+    kmsKeyArn: z.ZodOptional<z.ZodString>;
+    cors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        allowedOrigins: z.ZodArray<z.ZodString>;
+        allowedMethods: z.ZodArray<z.ZodString>;
+        allowedHeaders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exposedHeaders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxAge: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    connectionConfig: z.ZodOptional<z.ZodObject<{
+        connectToCompute: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        connectToServices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type S3ResourcePlan = z.infer<typeof S3ResourcePlanSchema>;
+export type S3GeneratorOptions = z.infer<typeof S3GeneratorSchema>;

package/dist/src/schemas/storageSchemas.js

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { VALIDATION_MESSAGES } from "../validation/patterns.js";
+import { BACKUP_VAULT_TIERS, S3_ENCRYPTION_TYPES, STORAGE_PRESET_TYPES, } from "./constants.js";
+import { ResourceNameSchema, BucketNameSchema, AppNameSchema, ExtraPropertySchema, } from "./baseSchemas.js";
+// ─── S3 resource plan ────────────────────────────────────────────────────────
+/**
+ * Stack placement options for S3 buckets.
+ * - "storage" (default): Created via app.addStorage() in Storage stack
+ * - "cdn": Created in CDN stack for CloudFront-consumed buckets (avoids circular dependencies)
+ * - "compute": Created in Compute stack for Lambda-consumed buckets
+ */
+export const S3_STACK_PLACEMENTS = ["storage", "cdn", "compute"];
+export const S3ResourcePlanSchema = z
+    .object({
+    name: ResourceNameSchema,
+    // Explicit S3 bucket name (user-provided, kebab-case)
+    bucketName: z.string().optional(),
+    // Access control (replaces bucketType)
+    publicReadAccess: z.boolean().optional(),
+    // Website hosting (presence-based)
+    websiteHosting: z
+        .object({
+        indexDocument: z.string(),
+        errorDocument: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+    // Core
+    backupVaultTier: z.enum(BACKUP_VAULT_TIERS).optional(),
+    versioned: z.boolean().optional(),
+    encryption: z.enum(S3_ENCRYPTION_TYPES).optional(),
+    kmsKeyArn: z.string().optional(),
+    // CORS (any bucket)
+    cors: z
+        .array(z
+        .object({
+        allowedOrigins: z.array(z.string()),
+        allowedMethods: z.array(z.string()),
+        allowedHeaders: z.array(z.string()).optional(),
+        exposedHeaders: z.array(z.string()).optional(),
+        maxAge: z.number().optional(),
+    })
+        .strict())
+        .optional(),
+    // Deployment (any bucket)
+    deployment: z
+        .object({
+        source: z.string(),
+        prune: z.boolean().optional(),
+        cacheControl: z
+            .object({
+            maxAge: z.number().optional(),
+            immutable: z.boolean().optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    // Stack placement
+    stackPlacement: z.enum(S3_STACK_PLACEMENTS).optional(),
+    // Round-trip preservation
+    variableName: z.string().optional(),
+    extraProperties: z.array(ExtraPropertySchema).optional(),
+})
+    .strict()
+    .refine((data) => data.encryption !== "KMS" || !!data.kmsKeyArn, {
+    message: VALIDATION_MESSAGES.KMS.KEY_REQUIRED,
+});
+// ─── S3 generator schema ────────────────────────────────────────────────────
+export const S3GeneratorSchema = z
+    .object({
+    appName: AppNameSchema,
+    bucketName: BucketNameSchema,
+    nameProvidedByFlag: z.boolean().optional(),
+    // Preset (generator-only -- resolved to params before plan creation)
+    storagePreset: z.enum(STORAGE_PRESET_TYPES).optional(),
+    // Explicit overrides
+    publicReadAccess: z.boolean().optional(),
+    websiteHosting: z
+        .object({
+        indexDocument: z.string(),
+        errorDocument: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+    // Core
+    backupVaultTier: z.enum(BACKUP_VAULT_TIERS).optional(),
+    versioned: z.boolean().optional(),
+    encryption: z.enum(S3_ENCRYPTION_TYPES).optional(),
+    kmsKeyArn: z.string().optional(),
+    // CORS
+    cors: z
+        .array(z
+        .object({
+        allowedOrigins: z.array(z.string()),
+        allowedMethods: z.array(z.string()),
+        allowedHeaders: z.array(z.string()).optional(),
+        exposedHeaders: z.array(z.string()).optional(),
+        maxAge: z.number().optional(),
+    })
+        .strict())
+        .optional(),
+    // Connection config (non-interactive mode)
+    connectionConfig: z
+        .object({
+        /** Connect to entire compute resources */
+        connectToCompute: z.array(z.string()).optional(),
+        /** Connect to specific ECS services (format: "ClusterName/ServiceName") */
+        connectToServices: z.array(z.string()).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .refine((data) => data.encryption !== "KMS" || !!data.kmsKeyArn, {
+    message: VALIDATION_MESSAGES.KMS.KEY_REQUIRED,
+    path: ["kmsKeyArn"],
+});

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

@@ -1,2 +1 @@
-export declare function normaliseError(error: unknown): Error;
-export declare function getErrorMessage(error: unknown): string;
+export { normaliseError, getErrorMessage, hasErrorCode, getErrorCode, getErrorStack, formatErrorString, } from "@fjall/util";

package/dist/src/util/errorUtils.js

@@ -1,15 +1 @@
-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";
-}
+export { normaliseError, getErrorMessage, hasErrorCode, getErrorCode, getErrorStack, formatErrorString, } from "@fjall/util";

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

@@ -104,6 +104,15 @@ export declare const VALIDATION_MESSAGES: Readonly<{
             readonly MIN: "Desired count must be at least 0";
             readonly MAX: "Desired count cannot exceed 100";
         };
+        readonly WARM_POOL_REQUIRED: "minCapacity 0 requires a warmPool — without it, new tasks wait 60-90s for a cold instance launch";
+        readonly WARM_POOL: {
+            readonly MIN_SIZE: {
+                readonly INTEGER: "Warm pool minSize must be an integer";
+                readonly MIN: "Warm pool minSize must be at least 0";
+                readonly MAX: "Warm pool minSize cannot exceed 100";
+            };
+            readonly MIN_SIZE_EXCEEDS_MAX_CAPACITY: "warmPool.minSize cannot exceed maxCapacity — the warm pool cannot hold more instances than the ASG allows";
+        };
     };
     readonly MEMORY_LIMIT: {
         readonly INTEGER: "Memory limit must be an integer";

package/dist/src/validation/patterns.js

@@ -133,6 +133,15 @@ export const VALIDATION_MESSAGES = Object.freeze({
             MIN: "Desired count must be at least 0",
             MAX: "Desired count cannot exceed 100",
         },
+        WARM_POOL_REQUIRED: "minCapacity 0 requires a warmPool — without it, new tasks wait 60-90s for a cold instance launch",
+        WARM_POOL: {
+            MIN_SIZE: {
+                INTEGER: "Warm pool minSize must be an integer",
+                MIN: "Warm pool minSize must be at least 0",
+                MAX: "Warm pool minSize cannot exceed 100",
+            },
+            MIN_SIZE_EXCEEDS_MAX_CAPACITY: "warmPool.minSize cannot exceed maxCapacity — the warm pool cannot hold more instances than the ASG allows",
+        },
     },
     // Memory limit validation messages (ECS)
     MEMORY_LIMIT: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fjall/generator",
-  "version": "0.88.4",
+  "version": "0.89.2",
   "description": "Pure infrastructure generation logic for Fjall",
   "type": "module",
   "main": "dist/src/index.js",
@@ -20,13 +20,14 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "license": "ISC",
+  "license": "MIT",
   "dependencies": {
+    "@fjall/util": "^0.89.2",
     "typescript": "^5.8.2",
     "zod": "^4.0.14"
   },
   "devDependencies": {
     "vitest": "^3.2.3"
   },
-  "gitHead": "bae02efe8e447ef008c7bc3eef3398ded4872f42"
+  "gitHead": "5bb039ff669fbe96d656ae1467e9986cf4327e92"
 }