@intentius/chant-lexicon-aws 0.0.2

package/src/codegen/patches.ts

@@ -0,0 +1,98 @@
+/**
+ * cfn-lint patch fetcher and applier.
+ *
+ * Downloads cfn-lint patches from GitHub and applies them to raw schemas
+ * before parsing. This enriches the schemas with additional type information,
+ * enum values, and constraint fixes.
+ */
+
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { rfc6902Apply } from "@intentius/chant/codegen/json-patch";
+import { fetchAndExtractTar } from "@intentius/chant/codegen/fetch";
+import { cfnLintTarballUrl } from "./versions";
+
+const CFN_LINT_TARBALL_URL = cfnLintTarballUrl();
+const PATCHES_DEST_DIR = join(homedir(), ".chant", "cfn-lint-patches");
+const PATCHES_TAR_PREFIX = "src/cfnlint/data/schemas/patches/extensions/all/";
+const PATCH_FILES = ["manual.json", "smithy.json", "format.json"] as const;
+
+export interface PatchWarning {
+  typeName: string;
+  patchFile: string;
+  error: Error;
+}
+
+export interface PatchStats {
+  patchesApplied: number;
+  resourcesFixed: number;
+  warnings: PatchWarning[];
+}
+
+/**
+ * Fetch cfn-lint patches from GitHub tarball and extract to cache.
+ * Returns the path to the extracted patches directory.
+ */
+export async function fetchCfnLintPatches(force = false): Promise<string> {
+  return fetchAndExtractTar(
+    { url: CFN_LINT_TARBALL_URL, destDir: PATCHES_DEST_DIR },
+    PATCHES_TAR_PREFIX,
+    force,
+  );
+}
+
+/**
+ * Apply cfn-lint RFC 6902 patches to raw schema bytes.
+ * For each schema, converts type name to directory name and applies
+ * manual.json, smithy.json, format.json in order.
+ */
+export function applyPatches(
+  schemas: Map<string, Buffer>,
+  patchesDir: string
+): { schemas: Map<string, Buffer>; stats: PatchStats } {
+  const stats: PatchStats = { patchesApplied: 0, resourcesFixed: 0, warnings: [] };
+  const result = new Map<string, Buffer>();
+
+  for (const [typeName, data] of schemas) {
+    const dirName = typeNameToPatchDir(typeName);
+    const patchPath = join(patchesDir, dirName);
+
+    let patched = data;
+    for (const pf of PATCH_FILES) {
+      const fullPath = join(patchPath, pf);
+      let patchData: Buffer;
+      try {
+        patchData = readFileSync(fullPath) as unknown as Buffer;
+      } catch {
+        continue; // Patch file doesn't exist
+      }
+
+      try {
+        patched = Buffer.from(rfc6902Apply(patched.toString("utf-8"), patchData.toString("utf-8")));
+        stats.patchesApplied++;
+      } catch (err) {
+        stats.warnings.push({
+          typeName,
+          patchFile: pf,
+          error: err instanceof Error ? err : new Error(String(err)),
+        });
+      }
+    }
+
+    if (patched !== data) {
+      stats.resourcesFixed++;
+    }
+    result.set(typeName, patched);
+  }
+
+  return { schemas: result, stats };
+}
+
+/**
+ * Convert CloudFormation type name to cfn-lint patch directory name.
+ * AWS::S3::Bucket → aws_s3_bucket
+ */
+export function typeNameToPatchDir(typeName: string): string {
+  return typeName.replaceAll("::", "_").toLowerCase();
+}

package/src/codegen/rollback.test.ts

@@ -0,0 +1,80 @@
+import { describe, test, expect } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { snapshotArtifacts, saveSnapshot, restoreSnapshot, listSnapshots } from "./rollback";
+
+function makeTempDir(): string {
+  const dir = join(tmpdir(), `chant-rollback-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("rollback", () => {
+  test("snapshot captures generated files", () => {
+    const dir = makeTempDir();
+    const genDir = join(dir, "generated");
+    mkdirSync(genDir, { recursive: true });
+
+    writeFileSync(join(genDir, "lexicon-aws.json"), '{"Bucket":{"kind":"resource"}}');
+    writeFileSync(join(genDir, "index.d.ts"), "declare class Bucket {}");
+    writeFileSync(join(genDir, "index.ts"), "export const Bucket = {};");
+
+    const snapshot = snapshotArtifacts(genDir);
+    expect(snapshot.files["lexicon-aws.json"]).toBeDefined();
+    expect(snapshot.files["index.d.ts"]).toBeDefined();
+    expect(snapshot.files["index.ts"]).toBeDefined();
+    expect(snapshot.hashes["lexicon-aws.json"]).toBeDefined();
+    expect(snapshot.resourceCount).toBe(1);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("save and list snapshots", () => {
+    const dir = makeTempDir();
+    const snapshotsDir = join(dir, ".snapshots");
+
+    const snapshot = {
+      timestamp: "2025-01-01T00:00:00.000Z",
+      files: { "test.json": "{}" },
+      hashes: { "test.json": "abc123" },
+      resourceCount: 0,
+    };
+
+    saveSnapshot(snapshot, snapshotsDir);
+    const list = listSnapshots(snapshotsDir);
+    expect(list.length).toBe(1);
+    expect(list[0].timestamp).toBe("2025-01-01T00:00:00.000Z");
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("restore snapshot overwrites generated files", () => {
+    const dir = makeTempDir();
+    const genDir = join(dir, "generated");
+    const snapshotsDir = join(dir, ".snapshots");
+    mkdirSync(genDir, { recursive: true });
+
+    // Write original files
+    writeFileSync(join(genDir, "lexicon-aws.json"), '{"original":true}');
+
+    // Snapshot them
+    const snapshot = snapshotArtifacts(genDir);
+    const snapshotPath = saveSnapshot(snapshot, snapshotsDir);
+
+    // Overwrite with new content
+    writeFileSync(join(genDir, "lexicon-aws.json"), '{"modified":true}');
+    expect(readFileSync(join(genDir, "lexicon-aws.json"), "utf-8")).toBe('{"modified":true}');
+
+    // Restore
+    restoreSnapshot(snapshotPath, genDir);
+    expect(readFileSync(join(genDir, "lexicon-aws.json"), "utf-8")).toBe('{"original":true}');
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("listSnapshots returns empty for nonexistent dir", () => {
+    const list = listSnapshots("/nonexistent/path");
+    expect(list).toHaveLength(0);
+  });
+});

package/src/codegen/rollback.ts

@@ -0,0 +1,20 @@
+/**
+ * Re-export from core with AWS-specific artifact names.
+ */
+import {
+  snapshotArtifacts as _snapshotArtifacts,
+  saveSnapshot,
+  restoreSnapshot,
+  listSnapshots,
+} from "@intentius/chant/codegen/rollback";
+export type { ArtifactSnapshot, SnapshotInfo } from "@intentius/chant/codegen/rollback";
+export { saveSnapshot, restoreSnapshot, listSnapshots };
+
+const AWS_ARTIFACT_NAMES = ["lexicon-aws.json", "index.d.ts", "index.ts"];
+
+/**
+ * Snapshot AWS lexicon artifacts.
+ */
+export function snapshotArtifacts(generatedDir: string) {
+  return _snapshotArtifacts(generatedDir, AWS_ARTIFACT_NAMES);
+}

package/src/codegen/sam.ts

@@ -0,0 +1,387 @@
+/**
+ * SAM (Serverless Application Model) resource definitions.
+ *
+ * Hand-authored since no machine-readable SAM spec exists.
+ * 9 resources matching the Go implementation.
+ */
+
+import type { SchemaParseResult, ParsedProperty, ParsedAttribute, ParsedPropertyType } from "../spec/parse";
+
+export function samResources(): SchemaParseResult[] {
+  return [
+    samFunction(),
+    samApi(),
+    samHttpApi(),
+    samSimpleTable(),
+    samLayerVersion(),
+    samStateMachine(),
+    samApplication(),
+    samConnector(),
+    samGraphQLApi(),
+  ];
+}
+
+function samFunction(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::Function",
+      properties: [
+        { name: "Handler", tsType: "string", required: true, constraints: {} },
+        { name: "Runtime", tsType: "string", required: true, constraints: {} },
+        { name: "CodeUri", tsType: "any", required: true, constraints: {} },
+        { name: "FunctionName", tsType: "string", required: false, constraints: {} },
+        { name: "Description", tsType: "string", required: false, constraints: {} },
+        { name: "MemorySize", tsType: "number", required: false, constraints: {} },
+        { name: "Timeout", tsType: "number", required: false, constraints: {} },
+        { name: "Role", tsType: "string", required: false, constraints: {} },
+        { name: "Policies", tsType: "any[]", required: false, constraints: {} },
+        { name: "Environment", tsType: "Function_Environment", required: false, constraints: {} },
+        { name: "Events", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "VpcConfig", tsType: "Function_VpcConfig", required: false, constraints: {} },
+        { name: "Architectures", tsType: "string[]", required: false, constraints: {} },
+        { name: "Layers", tsType: "string[]", required: false, constraints: {} },
+        { name: "Tracing", tsType: "string", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "DeadLetterQueue", tsType: "Function_DeadLetterQueue", required: false, constraints: {} },
+        { name: "DeploymentPreference", tsType: "Function_DeploymentPreference", required: false, constraints: {} },
+        { name: "ReservedConcurrentExecutions", tsType: "number", required: false, constraints: {} },
+        { name: "AutoPublishAlias", tsType: "string", required: false, constraints: {} },
+        { name: "PackageType", tsType: "string", required: false, constraints: {} },
+        { name: "ImageUri", tsType: "string", required: false, constraints: {} },
+        { name: "ImageConfig", tsType: "any", required: false, constraints: {} },
+        { name: "EphemeralStorage", tsType: "any", required: false, constraints: {} },
+        { name: "SnapStart", tsType: "any", required: false, constraints: {} },
+        { name: "FunctionUrlConfig", tsType: "any", required: false, constraints: {} },
+        { name: "InlineCode", tsType: "string", required: false, constraints: {} },
+      ],
+      attributes: [{ name: "Arn", tsType: "string" }],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [
+      {
+        name: "Function_Environment",
+        cfnType: "Environment",
+        properties: [
+          { name: "Variables", tsType: "Record<string, any>", required: false, constraints: {} },
+        ],
+      },
+      {
+        name: "Function_VpcConfig",
+        cfnType: "VpcConfig",
+        properties: [
+          { name: "SecurityGroupIds", tsType: "string[]", required: true, constraints: {} },
+          { name: "SubnetIds", tsType: "string[]", required: true, constraints: {} },
+        ],
+      },
+      {
+        name: "Function_DeadLetterQueue",
+        cfnType: "DeadLetterQueue",
+        properties: [
+          { name: "Type", tsType: "string", required: true, constraints: {} },
+          { name: "TargetArn", tsType: "string", required: true, constraints: {} },
+        ],
+      },
+      {
+        name: "Function_DeploymentPreference",
+        cfnType: "DeploymentPreference",
+        properties: [
+          { name: "Type", tsType: "string", required: true, constraints: {} },
+          { name: "Enabled", tsType: "boolean", required: false, constraints: {} },
+          { name: "Alarms", tsType: "string[]", required: false, constraints: {} },
+          { name: "Hooks", tsType: "any", required: false, constraints: {} },
+        ],
+      },
+      {
+        name: "Function_EventSource",
+        cfnType: "EventSource",
+        properties: [
+          { name: "Type", tsType: "string", required: true, constraints: {} },
+          { name: "Properties", tsType: "any", required: false, constraints: {} },
+        ],
+      },
+      {
+        name: "Function_S3Location",
+        cfnType: "S3Location",
+        properties: [
+          { name: "Bucket", tsType: "string", required: true, constraints: {} },
+          { name: "Key", tsType: "string", required: true, constraints: {} },
+          { name: "Version", tsType: "string", required: false, constraints: {} },
+        ],
+      },
+    ],
+    enums: [],
+  };
+}
+
+function samApi(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::Api",
+      properties: [
+        { name: "StageName", tsType: "string", required: true, constraints: {} },
+        { name: "DefinitionBody", tsType: "any", required: false, constraints: {} },
+        { name: "DefinitionUri", tsType: "any", required: false, constraints: {} },
+        { name: "Name", tsType: "string", required: false, constraints: {} },
+        { name: "Auth", tsType: "Api_Auth", required: false, constraints: {} },
+        { name: "Cors", tsType: "any", required: false, constraints: {} },
+        { name: "EndpointConfiguration", tsType: "string", required: false, constraints: {} },
+        { name: "TracingEnabled", tsType: "boolean", required: false, constraints: {} },
+        { name: "CacheClusterEnabled", tsType: "boolean", required: false, constraints: {} },
+        { name: "CacheClusterSize", tsType: "string", required: false, constraints: {} },
+        { name: "Variables", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "AccessLogSetting", tsType: "any", required: false, constraints: {} },
+        { name: "CanarySetting", tsType: "any", required: false, constraints: {} },
+        { name: "MethodSettings", tsType: "any[]", required: false, constraints: {} },
+        { name: "BinaryMediaTypes", tsType: "string[]", required: false, constraints: {} },
+        { name: "MinimumCompressionSize", tsType: "number", required: false, constraints: {} },
+        { name: "OpenApiVersion", tsType: "string", required: false, constraints: {} },
+        { name: "GatewayResponses", tsType: "Record<string, any>", required: false, constraints: {} },
+      ],
+      attributes: [{ name: "RootResourceId", tsType: "string" }],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [
+      {
+        name: "Api_Auth",
+        cfnType: "Auth",
+        properties: [
+          { name: "DefaultAuthorizer", tsType: "string", required: false, constraints: {} },
+          { name: "Authorizers", tsType: "Record<string, any>", required: false, constraints: {} },
+          { name: "ApiKeyRequired", tsType: "boolean", required: false, constraints: {} },
+          { name: "UsagePlan", tsType: "any", required: false, constraints: {} },
+        ],
+      },
+      {
+        name: "Api_CorsConfiguration",
+        cfnType: "CorsConfiguration",
+        properties: [
+          { name: "AllowOrigin", tsType: "string", required: true, constraints: {} },
+          { name: "AllowHeaders", tsType: "string", required: false, constraints: {} },
+          { name: "AllowMethods", tsType: "string", required: false, constraints: {} },
+          { name: "AllowCredentials", tsType: "boolean", required: false, constraints: {} },
+          { name: "MaxAge", tsType: "number", required: false, constraints: {} },
+        ],
+      },
+    ],
+    enums: [],
+  };
+}
+
+function samHttpApi(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::HttpApi",
+      properties: [
+        { name: "StageName", tsType: "string", required: false, constraints: {} },
+        { name: "DefinitionBody", tsType: "any", required: false, constraints: {} },
+        { name: "DefinitionUri", tsType: "any", required: false, constraints: {} },
+        { name: "Name", tsType: "string", required: false, constraints: {} },
+        { name: "CorsConfiguration", tsType: "any", required: false, constraints: {} },
+        { name: "Auth", tsType: "any", required: false, constraints: {} },
+        { name: "AccessLogSettings", tsType: "any", required: false, constraints: {} },
+        { name: "DefaultRouteSettings", tsType: "any", required: false, constraints: {} },
+        { name: "RouteSettings", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "StageVariables", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "FailOnWarnings", tsType: "boolean", required: false, constraints: {} },
+        { name: "DisableExecuteApiEndpoint", tsType: "boolean", required: false, constraints: {} },
+      ],
+      attributes: [{ name: "ApiEndpoint", tsType: "string" }],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [
+      {
+        name: "HttpApi_CorsConfiguration",
+        cfnType: "CorsConfiguration",
+        properties: [
+          { name: "AllowOrigins", tsType: "string[]", required: false, constraints: {} },
+          { name: "AllowHeaders", tsType: "string[]", required: false, constraints: {} },
+          { name: "AllowMethods", tsType: "string[]", required: false, constraints: {} },
+          { name: "AllowCredentials", tsType: "boolean", required: false, constraints: {} },
+          { name: "ExposeHeaders", tsType: "string[]", required: false, constraints: {} },
+          { name: "MaxAge", tsType: "number", required: false, constraints: {} },
+        ],
+      },
+    ],
+    enums: [],
+  };
+}
+
+function samSimpleTable(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::SimpleTable",
+      properties: [
+        { name: "PrimaryKey", tsType: "SimpleTable_PrimaryKey", required: false, constraints: {} },
+        { name: "ProvisionedThroughput", tsType: "any", required: false, constraints: {} },
+        { name: "TableName", tsType: "string", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "SSESpecification", tsType: "any", required: false, constraints: {} },
+      ],
+      attributes: [],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [
+      {
+        name: "SimpleTable_PrimaryKey",
+        cfnType: "PrimaryKey",
+        properties: [
+          { name: "Name", tsType: "string", required: true, constraints: {} },
+          { name: "Type", tsType: "string", required: true, constraints: {} },
+        ],
+      },
+    ],
+    enums: [],
+  };
+}
+
+function samLayerVersion(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::LayerVersion",
+      properties: [
+        { name: "ContentUri", tsType: "any", required: true, constraints: {} },
+        { name: "LayerName", tsType: "string", required: false, constraints: {} },
+        { name: "Description", tsType: "string", required: false, constraints: {} },
+        { name: "CompatibleRuntimes", tsType: "string[]", required: false, constraints: {} },
+        { name: "CompatibleArchitectures", tsType: "string[]", required: false, constraints: {} },
+        { name: "LicenseInfo", tsType: "string", required: false, constraints: {} },
+        { name: "RetentionPolicy", tsType: "string", required: false, constraints: {} },
+      ],
+      attributes: [
+        { name: "Arn", tsType: "string" },
+        { name: "LayerArn", tsType: "string" },
+      ],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [],
+    enums: [],
+  };
+}
+
+function samStateMachine(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::StateMachine",
+      properties: [
+        { name: "Definition", tsType: "any", required: false, constraints: {} },
+        { name: "DefinitionUri", tsType: "any", required: false, constraints: {} },
+        { name: "DefinitionSubstitutions", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "Name", tsType: "string", required: false, constraints: {} },
+        { name: "Role", tsType: "string", required: false, constraints: {} },
+        { name: "Policies", tsType: "any[]", required: false, constraints: {} },
+        { name: "Type", tsType: "string", required: false, constraints: {} },
+        { name: "Logging", tsType: "any", required: false, constraints: {} },
+        { name: "Tracing", tsType: "any", required: false, constraints: {} },
+        { name: "Events", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "PermissionsBoundary", tsType: "string", required: false, constraints: {} },
+      ],
+      attributes: [
+        { name: "Arn", tsType: "string" },
+        { name: "Name", tsType: "string" },
+      ],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [
+      {
+        name: "StateMachine_S3Location",
+        cfnType: "S3Location",
+        properties: [
+          { name: "Bucket", tsType: "string", required: true, constraints: {} },
+          { name: "Key", tsType: "string", required: true, constraints: {} },
+          { name: "Version", tsType: "string", required: false, constraints: {} },
+        ],
+      },
+    ],
+    enums: [],
+  };
+}
+
+function samApplication(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::Application",
+      properties: [
+        { name: "Location", tsType: "any", required: true, constraints: {} },
+        { name: "Parameters", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "NotificationArns", tsType: "string[]", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "TimeoutInMinutes", tsType: "number", required: false, constraints: {} },
+      ],
+      attributes: [{ name: "Outputs", tsType: "any" }],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [],
+    enums: [],
+  };
+}
+
+function samConnector(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::Connector",
+      properties: [
+        { name: "Source", tsType: "any", required: true, constraints: {} },
+        { name: "Destination", tsType: "any", required: true, constraints: {} },
+        { name: "Permissions", tsType: "string[]", required: true, constraints: {} },
+      ],
+      attributes: [],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [],
+    enums: [],
+  };
+}
+
+function samGraphQLApi(): SchemaParseResult {
+  return {
+    resource: {
+      typeName: "AWS::Serverless::GraphQLApi",
+      properties: [
+        { name: "SchemaUri", tsType: "string", required: false, constraints: {} },
+        { name: "SchemaInline", tsType: "string", required: false, constraints: {} },
+        { name: "Name", tsType: "string", required: false, constraints: {} },
+        { name: "Auth", tsType: "any", required: true, constraints: {} },
+        { name: "DataSources", tsType: "any", required: false, constraints: {} },
+        { name: "Functions", tsType: "any", required: false, constraints: {} },
+        { name: "Resolvers", tsType: "any", required: false, constraints: {} },
+        { name: "Logging", tsType: "any", required: false, constraints: {} },
+        { name: "XrayEnabled", tsType: "boolean", required: false, constraints: {} },
+        { name: "Tags", tsType: "Record<string, any>", required: false, constraints: {} },
+        { name: "Cache", tsType: "any", required: false, constraints: {} },
+        { name: "DomainName", tsType: "any", required: false, constraints: {} },
+      ],
+      attributes: [
+        { name: "ApiId", tsType: "string" },
+        { name: "Arn", tsType: "string" },
+        { name: "GraphQLUrl", tsType: "string" },
+        { name: "GraphQLDns", tsType: "string" },
+        { name: "RealtimeUrl", tsType: "string" },
+        { name: "RealtimeDns", tsType: "string" },
+      ],
+      createOnly: [],
+      writeOnly: [],
+      primaryIdentifier: [],
+    },
+    propertyTypes: [],
+    enums: [],
+  };
+}

package/src/codegen/snapshot.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect } from "bun:test";
+import { generate } from "./generate";
+import { loadSchemaFixtures } from "../testdata/load-fixtures";
+
+describe("snapshot tests", () => {
+  // Generate once for all snapshot tests
+  let result: Awaited<ReturnType<typeof generate>>;
+
+  test("generate from fixtures", async () => {
+    const fixtures = loadSchemaFixtures();
+    result = await generate({ schemaSource: fixtures });
+    expect(result.resources).toBeGreaterThanOrEqual(5);
+  });
+
+  test("Bucket lexicon entry", () => {
+    const lexicon = JSON.parse(result.lexiconJSON);
+    const bucket = lexicon["Bucket"];
+    expect(bucket).toBeDefined();
+    expect(bucket).toMatchSnapshot();
+  });
+
+  test("Function lexicon entry", () => {
+    const lexicon = JSON.parse(result.lexiconJSON);
+    const fn = lexicon["Function"];
+    expect(fn).toBeDefined();
+    expect(fn).toMatchSnapshot();
+  });
+
+  test("Role lexicon entry", () => {
+    const lexicon = JSON.parse(result.lexiconJSON);
+    const role = lexicon["Role"];
+    expect(role).toBeDefined();
+    expect(role).toMatchSnapshot();
+  });
+
+  test("generated resource names", () => {
+    const lexicon = JSON.parse(result.lexiconJSON);
+    const names = Object.keys(lexicon).sort();
+    expect(names).toMatchSnapshot();
+  });
+
+  test("Bucket .d.ts class declaration", () => {
+    // Extract the Bucket class from typesDTS
+    const lines = result.typesDTS.split("\n");
+    const bucketStart = lines.findIndex((l) => /class\s+Bucket\b/.test(l));
+    expect(bucketStart).toBeGreaterThan(-1);
+
+    // Find closing brace (simple: next line with just "}")
+    let bucketEnd = bucketStart + 1;
+    let braceDepth = 1;
+    while (bucketEnd < lines.length && braceDepth > 0) {
+      const line = lines[bucketEnd];
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      bucketEnd++;
+    }
+
+    const bucketClass = lines.slice(bucketStart, bucketEnd).join("\n");
+    expect(bucketClass).toMatchSnapshot();
+  });
+
+  test("Function .d.ts class declaration", () => {
+    const lines = result.typesDTS.split("\n");
+    // Look for "class Function" or "class LambdaFunction" — naming may vary
+    const fnStart = lines.findIndex((l) => /class\s+(Function|LambdaFunction)\b/.test(l));
+    expect(fnStart).toBeGreaterThan(-1);
+
+    let fnEnd = fnStart + 1;
+    let braceDepth = 1;
+    while (fnEnd < lines.length && braceDepth > 0) {
+      const line = lines[fnEnd];
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      fnEnd++;
+    }
+
+    const fnClass = lines.slice(fnStart, fnEnd).join("\n");
+    expect(fnClass).toMatchSnapshot();
+  });
+});