@fjall/generator 0.88.4 → 0.89.2

package/dist/src/ast/astStorageParser.js

@@ -0,0 +1,164 @@
+import * as ts from "typescript";
+import { S3_STACK_PLACEMENTS, } from "../schemas/resourceSchemas.js";
+import { S3_ENCRYPTION_TYPES, BACKUP_VAULT_TIERS, } from "../schemas/constants.js";
+import { asBoolean, asNumber, asString, asStringUnion, captureExtraProperties, collectFromAst, extractVariableName, isFactoryBuildCall, isFactoryMethodCall, isParsedObject, parseObjectLiteral, } from "./astCommonParser.js";
+const S3_BUCKET_CLASSES = new Set(["S3Bucket"]);
+export { S3_BUCKET_CLASSES };
+// ---- Extraction helpers ----
+function extractS3Resource(varDecl, newExpr, bucketClass) {
+    const variableName = ts.isIdentifier(varDecl.name) ? varDecl.name.text : "";
+    if (newExpr.arguments && newExpr.arguments.length >= 2) {
+        const nameArg = newExpr.arguments[1];
+        const resourceName = ts.isStringLiteral(nameArg) ? nameArg.text : "";
+        const configArg = newExpr.arguments.length >= 3 ? newExpr.arguments[2] : undefined;
+        const config = configArg && ts.isObjectLiteralExpression(configArg)
+            ? parseObjectLiteral(configArg)
+            : {};
+        return {
+            variableName,
+            resourceName,
+            bucketClass,
+            config,
+            node: varDecl,
+        };
+    }
+    return null;
+}
+function extractS3FactoryResource(addStorageCall, 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 config = parseObjectLiteral(configArg);
+    const variableName = extractVariableName(addStorageCall) ?? "";
+    return {
+        variableName,
+        resourceName: nameArg.text,
+        bucketClass: "StorageFactory",
+        config,
+        node: addStorageCall,
+    };
+}
+// ---- Public API ----
+/** Find S3 resources created via new S3Bucket() constructor pattern */
+export function findS3Resources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isVariableDeclaration(node) || !node.initializer)
+            return null;
+        if (!ts.isNewExpression(node.initializer))
+            return null;
+        const newExpr = node.initializer;
+        if (!ts.isIdentifier(newExpr.expression))
+            return null;
+        const bucketClass = newExpr.expression.text;
+        if (!S3_BUCKET_CLASSES.has(bucketClass))
+            return null;
+        return extractS3Resource(node, newExpr, bucketClass);
+    });
+}
+/** Find S3 resources created via app.addStorage(StorageFactory.build(...)) factory pattern */
+export function findS3FactoryResources(sourceFile) {
+    return collectFromAst(sourceFile, (node) => {
+        if (!ts.isCallExpression(node) || !isFactoryMethodCall(node, "addStorage"))
+            return null;
+        const storageArg = node.arguments[0];
+        if (!isFactoryBuildCall(storageArg, "StorageFactory"))
+            return null;
+        return extractS3FactoryResource(node, storageArg);
+    });
+}
+/** Convert parsed S3 resources to plan format */
+export function convertS3Resources(s3Resources) {
+    return s3Resources.map((s3) => ({
+        name: s3.resourceName,
+        ...(asString(s3.config.bucketName) && {
+            bucketName: asString(s3.config.bucketName),
+        }),
+        ...(asBoolean(s3.config.publicReadAccess) === true && {
+            publicReadAccess: true,
+        }),
+        ...(isParsedObject(s3.config.websiteHosting) &&
+            (() => {
+                const hosting = s3.config.websiteHosting;
+                return {
+                    websiteHosting: {
+                        indexDocument: asString(hosting.indexDocument) ?? "index.html",
+                        ...(asString(hosting.errorDocument) && {
+                            errorDocument: asString(hosting.errorDocument),
+                        }),
+                    },
+                };
+            })()),
+        ...(asStringUnion(s3.config.backupVaultTier, BACKUP_VAULT_TIERS) && {
+            backupVaultTier: asStringUnion(s3.config.backupVaultTier, BACKUP_VAULT_TIERS),
+        }),
+        ...(asBoolean(s3.config.versioned) !== undefined && {
+            versioned: asBoolean(s3.config.versioned),
+        }),
+        ...(asStringUnion(s3.config.encryption, S3_ENCRYPTION_TYPES) && {
+            encryption: asStringUnion(s3.config.encryption, S3_ENCRYPTION_TYPES),
+        }),
+        ...(asString(s3.config.kmsKeyArn) && {
+            kmsKeyArn: asString(s3.config.kmsKeyArn),
+        }),
+        ...(Array.isArray(s3.config.cors) &&
+            s3.config.cors.length > 0 && {
+            cors: s3.config.cors.filter(isParsedObject).map((rule) => ({
+                allowedOrigins: Array.isArray(rule.allowedOrigins)
+                    ? rule.allowedOrigins.filter((o) => typeof o === "string")
+                    : [],
+                allowedMethods: Array.isArray(rule.allowedMethods)
+                    ? rule.allowedMethods.filter((m) => typeof m === "string")
+                    : [],
+            })),
+        }),
+        ...(isParsedObject(s3.config.deployment) &&
+            (() => {
+                const deployment = s3.config.deployment;
+                return {
+                    deployment: {
+                        source: asString(deployment.source) ?? "",
+                        ...(asBoolean(deployment.prune) !== undefined && {
+                            prune: asBoolean(deployment.prune),
+                        }),
+                        ...(isParsedObject(deployment.cacheControl) &&
+                            (() => {
+                                const cache = deployment.cacheControl;
+                                return {
+                                    cacheControl: {
+                                        ...(asNumber(cache.maxAge) !== undefined && {
+                                            maxAge: asNumber(cache.maxAge),
+                                        }),
+                                        ...(asBoolean(cache.immutable) !== undefined && {
+                                            immutable: asBoolean(cache.immutable),
+                                        }),
+                                    },
+                                };
+                            })()),
+                    },
+                };
+            })()),
+        ...(asStringUnion(s3.config.stackPlacement, S3_STACK_PLACEMENTS) && {
+            stackPlacement: asStringUnion(s3.config.stackPlacement, S3_STACK_PLACEMENTS),
+        }),
+        ...(s3.variableName && { variableName: s3.variableName }),
+        ...(() => {
+            const S3_KNOWN_KEYS = new Set([
+                "bucketName",
+                "publicReadAccess",
+                "websiteHosting",
+                "backupVaultTier",
+                "versioned",
+                "encryption",
+                "kmsKeyArn",
+                "cors",
+                "deployment",
+                "stackPlacement",
+            ]);
+            const extras = captureExtraProperties(s3.config, S3_KNOWN_KEYS);
+            return extras.length > 0 ? { extraProperties: extras } : {};
+        })(),
+    }));
+}

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

@@ -1,2 +1,3 @@
+export { type IdentifierRef, type ExpressionRef, type CallRef, type ParsedValue, type ParsedObject, isPlainObject, isIdentifierRef, isExpressionRef, isCallRef, isParsedObject, asString, asNumber, asBoolean, asStringArray, asStringUnion, captureExtraProperties, } from "./astCommonParser.js";
 export { type ParsedInfrastructure, type ParsedDatabaseResource, type ParsedS3Resource, type ParsedComputeResource, type ParsedSQSResource, type ParsedCDNResource, type ParsedNetworkResource, type ParsedDynamoDBResource, type ParsedLambdaConfig, type ParsedPatternResource, type ImportInfo, type StatementType, type ClassifiedStatement, type CustomCodeBlock, parseInfrastructure, convertToResourcePlan, classifyStatements, extractCustomCodeBlocks, findManagedResourcePosition, getLastManagedStatementOfType, getManagedResourcesByType, } from "./astInfrastructureParser.js";
 export { type SurgicalModificationResult, type InsertionOptions, type UpdateOptions, type DeleteOptions, type FileValidationResult, addResourceSurgically, updateResourceSurgically, removeResourceSurgically, ensureImports, injectCustomCodeBlocks, validateModifiedFile, } from "./astSurgicalModification.js";

package/dist/src/ast/index.js

@@ -1,2 +1,6 @@
+// Common AST parsing utilities
+export { isPlainObject, isIdentifierRef, isExpressionRef, isCallRef, isParsedObject, asString, asNumber, asBoolean, asStringArray, asStringUnion, captureExtraProperties, } from "./astCommonParser.js";
+// Main orchestration and types
 export { parseInfrastructure, convertToResourcePlan, classifyStatements, extractCustomCodeBlocks, findManagedResourcePosition, getLastManagedStatementOfType, getManagedResourcesByType, } from "./astInfrastructureParser.js";
+// Surgical modification
 export { addResourceSurgically, updateResourceSurgically, removeResourceSurgically, ensureImports, injectCustomCodeBlocks, validateModifiedFile, } from "./astSurgicalModification.js";

package/dist/src/dns/bindParser.d.ts

@@ -0,0 +1,13 @@
+import { type Result } from "../types/Result.js";
+import type { ParsedZoneFile } from "./types.js";
+export declare function parseZoneFile(content: string): Result<ParsedZoneFile, Error>;
+/**
+ * Resolve an ALIAS value (e.g. "fjall:ecs:my-app") to a target DNS name
+ * using a map of app outputs. Returns undefined if the alias cannot be resolved.
+ *
+ * Alias format: fjall:<type>:<name>
+ *   - fjall:ecs:<name> — resolves to ALB DNS name
+ *   - fjall:cdn:<name> — resolves to CloudFront domain name
+ *   - fjall:s3:<name> — resolves to S3 website endpoint
+ */
+export declare function resolveAlias(alias: string, appOutputs: Map<string, string>): string | undefined;

package/dist/src/dns/bindParser.js

@@ -0,0 +1,224 @@
+import { success, failure } from "../types/Result.js";
+import { DnsRecordTypeSchema, BIND_DIRECTIVES, ALIAS_PREFIX } from "./types.js";
+const RECORD_TYPES = new Set(DnsRecordTypeSchema.options);
+function isRecordType(token) {
+    return RECORD_TYPES.has(token.toUpperCase());
+}
+function stripTrailingDot(value) {
+    return value.endsWith(".") ? value.slice(0, -1) : value;
+}
+function stripInlineComment(line) {
+    let inQuote = false;
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] === '"') {
+            inQuote = !inQuote;
+        }
+        else if (line[i] === ";" && !inQuote) {
+            return line.slice(0, i).trimEnd();
+        }
+    }
+    return line;
+}
+function parseTxtValue(tokens, startIndex) {
+    const raw = tokens.slice(startIndex).join(" ");
+    const parts = [];
+    let current = "";
+    let inQuote = false;
+    for (const ch of raw) {
+        if (ch === '"') {
+            if (inQuote) {
+                parts.push(current);
+                current = "";
+            }
+            inQuote = !inQuote;
+        }
+        else if (inQuote) {
+            current += ch;
+        }
+    }
+    return parts.join(" ");
+}
+function parseDelegateDirective(line) {
+    const auto = /;\s*auto\s*$/.test(line);
+    const cleaned = line.replace(/;\s*auto\s*$/, "").trim();
+    const match = cleaned.match(/^\$FJALL-DELEGATE\s+(\S+)\s+TO\s+(\S+)$/i);
+    if (!match)
+        return undefined;
+    return { subdomain: match[1], targetAccount: match[2], auto };
+}
+function parseCertDirective(tokens) {
+    if (tokens.length < 2)
+        return undefined;
+    const domainName = tokens[1];
+    const sans = tokens.slice(2);
+    return { domainName, subjectAlternativeNames: sans };
+}
+function tokenise(line) {
+    const tokens = [];
+    let current = "";
+    let inQuote = false;
+    for (const ch of line) {
+        if (ch === '"') {
+            inQuote = !inQuote;
+            current += ch;
+        }
+        else if (/\s/.test(ch) && !inQuote) {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.length > 0)
+        tokens.push(current);
+    return tokens;
+}
+function parseRecord(tokens) {
+    if (tokens.length < 2)
+        return undefined;
+    let idx = 0;
+    const name = tokens[idx++];
+    let ttl;
+    let type;
+    // Next token could be TTL, class (IN), or record type
+    while (idx < tokens.length && type === undefined) {
+        const upper = tokens[idx].toUpperCase();
+        if (upper === "IN") {
+            idx++;
+        }
+        else if (isRecordType(upper)) {
+            type = upper;
+            idx++;
+        }
+        else if (/^\d+$/.test(tokens[idx])) {
+            ttl = parseInt(tokens[idx], 10);
+            idx++;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (!type)
+        return undefined;
+    const remaining = tokens.slice(idx);
+    switch (type) {
+        case "MX": {
+            if (remaining.length < 2)
+                return undefined;
+            const priority = parseInt(remaining[0], 10);
+            const value = remaining.slice(1).join(" ");
+            return { name, type, ttl, value, priority };
+        }
+        case "SRV": {
+            if (remaining.length < 4)
+                return undefined;
+            const priority = parseInt(remaining[0], 10);
+            const weight = parseInt(remaining[1], 10);
+            const port = parseInt(remaining[2], 10);
+            const value = remaining[3];
+            return { name, type, ttl, value, priority, weight, port };
+        }
+        case "TXT": {
+            const value = parseTxtValue(tokens, idx);
+            return { name, type, ttl, value };
+        }
+        case "CAA": {
+            const value = remaining.join(" ");
+            return { name, type, ttl, value };
+        }
+        case "A": {
+            if (remaining.length === 0)
+                return undefined;
+            const firstToken = remaining[0];
+            if (firstToken.toUpperCase() === "ALIAS") {
+                if (remaining.length < 2)
+                    return undefined;
+                const value = remaining.slice(1).join(" ");
+                return { name, type, ttl, value: `${ALIAS_PREFIX}${value}` };
+            }
+            return { name, type, ttl, value: remaining[0] };
+        }
+        default: {
+            if (remaining.length === 0)
+                return undefined;
+            return { name, type, ttl, value: remaining[0] };
+        }
+    }
+}
+export function parseZoneFile(content) {
+    const lines = content.split("\n");
+    let origin;
+    let ttl = 300;
+    const records = [];
+    const delegations = [];
+    const certificates = [];
+    for (const rawLine of lines) {
+        const trimmed = rawLine.trim();
+        if (trimmed === "" || trimmed.startsWith(";"))
+            continue;
+        if (trimmed.toUpperCase().startsWith(BIND_DIRECTIVES.FJALL_DELEGATE)) {
+            const directive = parseDelegateDirective(trimmed);
+            if (directive) {
+                delegations.push(directive);
+            }
+            continue;
+        }
+        const stripped = stripInlineComment(trimmed);
+        if (stripped === "")
+            continue;
+        const tokens = tokenise(stripped);
+        if (tokens.length === 0)
+            continue;
+        const directive = tokens[0].toUpperCase();
+        if (directive === BIND_DIRECTIVES.ORIGIN) {
+            if (tokens.length < 2)
+                continue;
+            origin = stripTrailingDot(tokens[1]);
+            continue;
+        }
+        if (directive === BIND_DIRECTIVES.TTL) {
+            if (tokens.length < 2)
+                continue;
+            ttl = parseInt(tokens[1], 10);
+            continue;
+        }
+        if (directive === BIND_DIRECTIVES.FJALL_CERT) {
+            const cert = parseCertDirective(tokens);
+            if (cert) {
+                certificates.push(cert);
+            }
+            continue;
+        }
+        const record = parseRecord(tokens);
+        if (record) {
+            records.push(record);
+        }
+    }
+    if (!origin) {
+        return failure(new Error("Missing $ORIGIN directive"));
+    }
+    return success({ origin, ttl, records, delegations, certificates });
+}
+/**
+ * Resolve an ALIAS value (e.g. "fjall:ecs:my-app") to a target DNS name
+ * using a map of app outputs. Returns undefined if the alias cannot be resolved.
+ *
+ * Alias format: fjall:<type>:<name>
+ *   - fjall:ecs:<name> — resolves to ALB DNS name
+ *   - fjall:cdn:<name> — resolves to CloudFront domain name
+ *   - fjall:s3:<name> — resolves to S3 website endpoint
+ */
+export function resolveAlias(alias, appOutputs) {
+    if (!alias.startsWith("fjall:"))
+        return undefined;
+    const parts = alias.split(":");
+    if (parts.length < 3)
+        return undefined;
+    const resourceType = parts[1];
+    const resourceName = parts[2];
+    const lookupKey = `${resourceType}:${resourceName}`;
+    return appOutputs.get(lookupKey) ?? appOutputs.get(alias);
+}

package/dist/src/dns/bindWriter.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedZoneFile } from "./types.js";
+export declare function generateZoneFile(zone: ParsedZoneFile): string;

package/dist/src/dns/bindWriter.js

@@ -0,0 +1,52 @@
+import { BIND_DIRECTIVES, ALIAS_PREFIX } from "./types.js";
+function padRight(value, width) {
+    return value.length >= width
+        ? value
+        : value + " ".repeat(width - value.length);
+}
+function formatRecord(record, defaultTtl) {
+    const nameCol = padRight(record.name, 24);
+    const hasTtl = record.ttl !== undefined && record.ttl !== defaultTtl;
+    const ttlStr = hasTtl ? `${record.ttl} ` : "";
+    switch (record.type) {
+        case "MX":
+            return `${nameCol} ${ttlStr}IN MX ${record.priority ?? 10} ${record.value}`;
+        case "SRV":
+            return `${nameCol} ${ttlStr}IN SRV ${record.priority ?? 0} ${record.weight ?? 0} ${record.port ?? 0} ${record.value}`;
+        case "TXT":
+            return `${nameCol} ${ttlStr}IN TXT "${record.value}"`;
+        case "CAA":
+            return `${nameCol} ${ttlStr}IN CAA ${record.value}`;
+        default: {
+            if (record.type === "A" && record.value.startsWith(ALIAS_PREFIX)) {
+                return `${nameCol} ${ttlStr}IN A ${record.value}`;
+            }
+            return `${nameCol} ${ttlStr}IN ${record.type} ${record.value}`;
+        }
+    }
+}
+export function generateZoneFile(zone) {
+    const lines = [];
+    lines.push("; zone.bind — managed by fjall");
+    lines.push(`${BIND_DIRECTIVES.ORIGIN} ${zone.origin}.`);
+    lines.push(`${BIND_DIRECTIVES.TTL} ${zone.ttl}`);
+    lines.push("");
+    if (zone.certificates.length > 0) {
+        for (const cert of zone.certificates) {
+            const parts = [cert.domainName, ...cert.subjectAlternativeNames];
+            lines.push(`${BIND_DIRECTIVES.FJALL_CERT} ${parts.join(" ")}`);
+        }
+        lines.push("");
+    }
+    if (zone.delegations.length > 0) {
+        for (const delegation of zone.delegations) {
+            const suffix = delegation.auto ? " ; auto" : "";
+            lines.push(`${BIND_DIRECTIVES.FJALL_DELEGATE} ${delegation.subdomain} TO ${delegation.targetAccount}${suffix}`);
+        }
+        lines.push("");
+    }
+    for (const record of zone.records) {
+        lines.push(formatRecord(record, zone.ttl));
+    }
+    return lines.join("\n") + "\n";
+}

package/dist/src/dns/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { parseZoneFile, resolveAlias } from "./bindParser.js";
+export { generateZoneFile } from "./bindWriter.js";
+export { generateInfrastructureFromZone } from "./infrastructureWriter.js";

package/dist/src/dns/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { parseZoneFile, resolveAlias } from "./bindParser.js";
+export { generateZoneFile } from "./bindWriter.js";
+export { generateInfrastructureFromZone } from "./infrastructureWriter.js";

package/dist/src/dns/infrastructureWriter.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedZoneFile } from "./types.js";
+export declare function generateInfrastructureFromZone(domainName: string, zone: ParsedZoneFile): string;

package/dist/src/dns/infrastructureWriter.js

@@ -0,0 +1,58 @@
+import { toPascalCase } from "../generation/common.js";
+import { ALIAS_PREFIX, } from "./types.js";
+function escapeString(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, "\\$")
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r");
+}
+export function generateInfrastructureFromZone(domainName, zone) {
+    const safeZoneName = toPascalCase(domainName.split(".").join(""));
+    const records = zone.records
+        .filter((r) => !r.value.startsWith(ALIAS_PREFIX))
+        .map((r) => {
+        const parts = [
+            `      { type: "${escapeString(r.type)}", name: "${escapeString(r.name)}", value: "${escapeString(r.value)}"`,
+        ];
+        if (r.priority !== undefined)
+            parts.push(`, priority: ${r.priority}`);
+        if (r.ttl !== undefined)
+            parts.push(`, ttl: ${r.ttl}`);
+        return parts.join("") + " }";
+    });
+    const aliasRecords = zone.records
+        .filter((r) => r.value.startsWith(ALIAS_PREFIX))
+        .map((r) => `      // ALIAS: ${escapeString(r.name)} → ${escapeString(r.value)} (resolved at deploy time)`);
+    const delegations = zone.delegations
+        .filter((d) => d.auto)
+        .map((d) => `      { subdomain: "${escapeString(d.subdomain)}", targetAccount: "${escapeString(d.targetAccount)}" }`);
+    const certificates = zone.certificates.map((c) => {
+        const sans = c.subjectAlternativeNames.length > 0
+            ? `, subjectAlternativeNames: [${c.subjectAlternativeNames.map((s) => `"${escapeString(s)}"`).join(", ")}]`
+            : "";
+        return `      { domainName: "${escapeString(c.domainName)}"${sans} }`;
+    });
+    return `import {
+  App,
+  DomainFactory,
+} from "@fjall/components-infrastructure";
+
+const app = App.getApp("${safeZoneName}Domain");
+
+DomainFactory.build("${safeZoneName}", {
+  type: "domain",
+  zoneName: "${escapeString(domainName)}",
+  records: [
+${records.join(",\n")}
+  ],
+  delegations: [
+${delegations.join(",\n")}
+  ],
+  certificates: [
+${certificates.join(",\n")}
+  ],
+});
+${aliasRecords.length > 0 ? "\n" + aliasRecords.join("\n") + "\n" : ""}`;
+}

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

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export { DNS_APEX, getDomainExportNames, type ManagedDomainExports, } from "@fjall/util";
+export declare const DnsRecordTypeSchema: z.ZodEnum<{
+    A: "A";
+    AAAA: "AAAA";
+    CNAME: "CNAME";
+    MX: "MX";
+    TXT: "TXT";
+    NS: "NS";
+    SRV: "SRV";
+    CAA: "CAA";
+}>;
+export type DnsRecordType = z.infer<typeof DnsRecordTypeSchema>;
+export declare const DnsRecordSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        A: "A";
+        AAAA: "AAAA";
+        CNAME: "CNAME";
+        MX: "MX";
+        TXT: "TXT";
+        NS: "NS";
+        SRV: "SRV";
+        CAA: "CAA";
+    }>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    value: z.ZodString;
+    priority: z.ZodOptional<z.ZodNumber>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    port: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const DelegationDirectiveSchema: z.ZodObject<{
+    subdomain: z.ZodString;
+    targetAccount: z.ZodString;
+    auto: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const CertificateDirectiveSchema: z.ZodObject<{
+    domainName: z.ZodString;
+    subjectAlternativeNames: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const ParsedZoneFileSchema: z.ZodObject<{
+    origin: z.ZodString;
+    ttl: z.ZodNumber;
+    records: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            A: "A";
+            AAAA: "AAAA";
+            CNAME: "CNAME";
+            MX: "MX";
+            TXT: "TXT";
+            NS: "NS";
+            SRV: "SRV";
+            CAA: "CAA";
+        }>;
+        ttl: z.ZodOptional<z.ZodNumber>;
+        value: z.ZodString;
+        priority: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        port: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    delegations: z.ZodArray<z.ZodObject<{
+        subdomain: z.ZodString;
+        targetAccount: z.ZodString;
+        auto: z.ZodBoolean;
+    }, z.core.$strict>>;
+    certificates: z.ZodArray<z.ZodObject<{
+        domainName: z.ZodString;
+        subjectAlternativeNames: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ParsedZoneFile = z.infer<typeof ParsedZoneFileSchema>;
+export type DnsRecord = z.infer<typeof DnsRecordSchema>;
+export type DelegationDirective = z.infer<typeof DelegationDirectiveSchema>;
+export type CertificateDirective = z.infer<typeof CertificateDirectiveSchema>;
+export declare const BIND_DIRECTIVES: Readonly<{
+    readonly ORIGIN: "$ORIGIN";
+    readonly TTL: "$TTL";
+    readonly FJALL_DELEGATE: "$FJALL-DELEGATE";
+    readonly FJALL_CERT: "$FJALL-CERT";
+}>;
+export declare const ALIAS_PREFIX: "ALIAS ";

package/dist/src/dns/types.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export { DNS_APEX, getDomainExportNames, } from "@fjall/util";
+export const DnsRecordTypeSchema = z.enum([
+    "A",
+    "AAAA",
+    "CNAME",
+    "MX",
+    "TXT",
+    "NS",
+    "SRV",
+    "CAA",
+]);
+export const DnsRecordSchema = z
+    .object({
+    name: z.string(),
+    type: DnsRecordTypeSchema,
+    ttl: z.number().optional(),
+    value: z.string(),
+    priority: z.number().optional(),
+    weight: z.number().optional(),
+    port: z.number().optional(),
+})
+    .strict();
+export const DelegationDirectiveSchema = z
+    .object({
+    subdomain: z.string(),
+    targetAccount: z.string(),
+    auto: z.boolean(),
+})
+    .strict();
+export const CertificateDirectiveSchema = z
+    .object({
+    domainName: z.string(),
+    subjectAlternativeNames: z.array(z.string()),
+})
+    .strict();
+export const ParsedZoneFileSchema = z
+    .object({
+    origin: z.string(),
+    ttl: z.number(),
+    records: z.array(DnsRecordSchema),
+    delegations: z.array(DelegationDirectiveSchema),
+    certificates: z.array(CertificateDirectiveSchema),
+})
+    .strict();
+export const BIND_DIRECTIVES = Object.freeze({
+    ORIGIN: "$ORIGIN",
+    TTL: "$TTL",
+    FJALL_DELEGATE: "$FJALL-DELEGATE",
+    FJALL_CERT: "$FJALL-CERT",
+});
+export const ALIAS_PREFIX = "ALIAS ";