alchemy 0.2.5 → 0.3.1

package/lib/dns/import-dns.d.ts

@@ -0,0 +1,82 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { type DnsRecordType } from "./record";
+/**
+ * DNS record response structure from Cloudflare DNS API
+ * with both data (original) and content (for compatibility)
+ */
+export interface DnsApiRecord {
+    name: string;
+    type: DnsRecordType;
+    TTL: number;
+    data: string;
+    content: string;
+    ttl: number;
+    priority?: number;
+}
+/**
+ * Properties for importing DNS records
+ */
+export interface ImportDnsRecordsProps {
+    /**
+     * The domain to fetch DNS records for
+     */
+    domain: string;
+    /**
+     * Specific record types to fetch. If not provided, defaults to all supported types.
+     */
+    recordTypes?: DnsRecordType[];
+    /**
+     * Bump the resource to force a new import
+     */
+    bump?: number;
+}
+/**
+ * Output returned after DNS records import
+ */
+export interface ImportDnsRecords extends Resource<"dns::ImportDnsRecords">, ImportDnsRecordsProps {
+    /**
+     * The DNS records as a flat array, directly compatible with DnsRecords function
+     */
+    records: DnsApiRecord[];
+    /**
+     * Time at which the records were imported
+     */
+    importedAt: number;
+}
+/**
+ * Import DNS records for a domain using Cloudflare's DNS-over-HTTPS API.
+ * This resource allows you to fetch DNS records for a domain and store them
+ * in a structured format.
+ *
+ * @example
+ * // Import all default record types
+ * const allRecords = await ImportDnsRecords("example.com", {
+ *   domain: "example.com"
+ * });
+ *
+ * @example
+ * // Import only specific record types
+ * const specificRecords = await ImportDnsRecords("example.com", {
+ *   domain: "example.com",
+ *   recordTypes: ["A", "MX"]
+ * });
+ *
+ * @example
+ * // Import DNS records and transfer them to a Cloudflare zone
+ * const dnsRecords = await ImportDnsRecords("dns-records", {
+ *   domain: "example.com",
+ * });
+ *
+ * const zone = await Zone("example.com", {
+ *   name: "example.com",
+ *   type: "full",
+ * });
+ *
+ * // Records are directly compatible with DnsRecords function
+ * await DnsRecords("transfer-dns-records", {
+ *   zoneId: zone.id,
+ *   records: dnsRecords.records,
+ * });
+ */
+export declare const ImportDnsRecords: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<ImportDnsRecords>, id: string, props: ImportDnsRecordsProps) => Promise<ImportDnsRecords>);

package/lib/dns/import-dns.js

@@ -0,0 +1,114 @@
+import { Resource } from "../resource";
+import { DEFAULT_RECORD_TYPES } from "./record";
+/**
+ * Map numeric DNS record type to string type
+ */
+function mapDnsRecordType(type) {
+    const typeMap = {
+        1: "A",
+        2: "NS",
+        5: "CNAME",
+        6: "SOA",
+        15: "MX",
+        16: "TXT",
+        28: "AAAA",
+        33: "SRV",
+        12: "PTR",
+    };
+    return typeMap[type] || "A";
+}
+/**
+ * Import DNS records for a domain using Cloudflare's DNS-over-HTTPS API.
+ * This resource allows you to fetch DNS records for a domain and store them
+ * in a structured format.
+ *
+ * @example
+ * // Import all default record types
+ * const allRecords = await ImportDnsRecords("example.com", {
+ *   domain: "example.com"
+ * });
+ *
+ * @example
+ * // Import only specific record types
+ * const specificRecords = await ImportDnsRecords("example.com", {
+ *   domain: "example.com",
+ *   recordTypes: ["A", "MX"]
+ * });
+ *
+ * @example
+ * // Import DNS records and transfer them to a Cloudflare zone
+ * const dnsRecords = await ImportDnsRecords("dns-records", {
+ *   domain: "example.com",
+ * });
+ *
+ * const zone = await Zone("example.com", {
+ *   name: "example.com",
+ *   type: "full",
+ * });
+ *
+ * // Records are directly compatible with DnsRecords function
+ * await DnsRecords("transfer-dns-records", {
+ *   zoneId: zone.id,
+ *   records: dnsRecords.records,
+ * });
+ */
+export const ImportDnsRecords = Resource("dns::ImportDnsRecords", async function (id, props) {
+    // For delete phase, just return destroyed state since this is a read-only resource
+    if (this.phase === "delete") {
+        return this.destroy();
+    }
+    const recordTypes = props.recordTypes || DEFAULT_RECORD_TYPES;
+    const allRecords = [];
+    for (const type of recordTypes) {
+        try {
+            const res = await fetch(`https://cloudflare-dns.com/dns-query?name=${props.domain}&type=${type}`, {
+                headers: {
+                    accept: "application/dns-json",
+                },
+            });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch ${type} records: ${res.statusText}`);
+            }
+            const data = (await res.json());
+            if (data.Answer) {
+                // Transform records to be compatible with DnsRecords function
+                const compatRecords = data.Answer.map((record) => {
+                    const recordType = mapDnsRecordType(record.type);
+                    const result = {
+                        name: record.name,
+                        type: recordType,
+                        TTL: record.TTL,
+                        data: record.data,
+                        content: record.data, // Default mapping
+                        ttl: record.TTL, // Normalized lowercase ttl
+                    };
+                    // Special handling for MX records to split priority and content
+                    if (recordType === "MX") {
+                        const parts = record.data.split(" ");
+                        if (parts.length >= 2) {
+                            const priority = Number.parseInt(parts[0], 10);
+                            // Join the rest as hostname in case there are spaces
+                            const hostname = parts.slice(1).join(" ");
+                            if (!isNaN(priority)) {
+                                result.priority = priority;
+                                result.content = hostname;
+                            }
+                        }
+                    }
+                    return result;
+                });
+                allRecords.push(...compatRecords);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to fetch ${type} records for ${props.domain}:`, error);
+        }
+    }
+    // Return the resource with fetched records as a flat array
+    return this({
+        domain: props.domain,
+        recordTypes: [...recordTypes],
+        records: allRecords,
+        importedAt: Date.now(),
+    });
+});

package/lib/dns/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./import-dns";
+export * from "./record";

package/lib/dns/index.js

@@ -0,0 +1,2 @@
+export * from "./import-dns";
+export * from "./record";

package/lib/dns/record.d.ts

@@ -0,0 +1,88 @@
+/**
+ * DNS record types supported across different providers
+ */
+export type DnsRecordType = "A" | "AAAA" | "MX" | "TXT" | "NS" | "CNAME" | "SOA" | "SRV" | "PTR";
+/**
+ * Default DNS record types to fetch
+ */
+export declare const DEFAULT_RECORD_TYPES: readonly DnsRecordType[];
+/**
+ * Base DNS record interface with common properties
+ */
+export interface DnsRecordBase {
+    /**
+     * DNS record name (e.g., "example.com", "subdomain.example.com")
+     */
+    name: string;
+    /**
+     * Record type (A, AAAA, CNAME, etc.)
+     */
+    type: DnsRecordType;
+}
+/**
+ * DNS record response structure from DNS-over-HTTPS APIs
+ */
+export interface DohDnsRecord extends DnsRecordBase {
+    /**
+     * Time To Live in seconds
+     */
+    TTL: number;
+    /**
+     * Record data/content (varies by record type)
+     */
+    data: string;
+}
+/**
+ * Comprehensive DNS record structure for creating/managing records
+ */
+export interface DnsRecord extends DnsRecordBase {
+    /**
+     * DNS record content (e.g., IP address, hostname)
+     */
+    content: string;
+    /**
+     * Time To Live (TTL) in seconds
+     * Setting to 1 means 'automatic'
+     * Value must be between 60 and 86400, with minimum reduced to 30 for Enterprise zones
+     * @default 1
+     */
+    ttl?: number;
+    /**
+     * Whether the record is receiving proxied traffic through Cloudflare
+     * @default false
+     */
+    proxied?: boolean;
+    /**
+     * Comments or notes about the record
+     */
+    comment?: string;
+    /**
+     * Record tags
+     */
+    tags?: string[];
+    /**
+     * Priority value for MX/SRV records
+     */
+    priority?: number;
+}
+/**
+ * DNS record with provider-specific ID and metadata
+ */
+export interface DnsRecordWithMetadata extends DnsRecord {
+    /**
+     * Record ID
+     */
+    id: string;
+    /**
+     * Zone or domain ID the record belongs to
+     */
+    zoneId: string;
+    /**
+     * Time at which the record was created
+     */
+    createdAt: number;
+    /**
+     * Time at which the record was last modified
+     */
+    modifiedAt?: number;
+}

package/lib/dns/record.js

@@ -0,0 +1,13 @@
+/**
+ * Default DNS record types to fetch
+ */
+export const DEFAULT_RECORD_TYPES = [
+    "A",
+    "AAAA",
+    "MX",
+    "TXT",
+    "NS",
+    "CNAME",
+    "SOA",
+    "SRV",
+];

package/lib/fs/copy-file.d.ts

@@ -0,0 +1,54 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+/**
+ * Properties for creating a CopyFile resource
+ */
+export interface CopyFileProps {
+    /**
+     * Source path of the file to copy
+     */
+    src: string;
+    /**
+     * Destination path where the file should be copied to
+     */
+    dest: string;
+    /**
+     * Whether to overwrite the destination file if it already exists
+     * @default true
+     */
+    overwrite?: boolean;
+}
+/**
+ * Output returned after CopyFile creation/update
+ */
+export interface CopyFile extends Resource<"fs::CopyFile">, CopyFileProps {
+    /**
+     * Time at which the object was created
+     */
+    createdAt: number;
+    /**
+     * Whether the file was successfully copied
+     */
+    copied: boolean;
+}
+/**
+ * CopyFile Resource
+ *
+ * Copies a file from a source location to a destination location.
+ *
+ * @example
+ * // Copy a file to a new location
+ * const copiedFile = await CopyFile("config-copy", {
+ *   src: "config.json",
+ *   dest: "backup/config.json"
+ * });
+ *
+ * @example
+ * // Copy a file without overwriting if destination exists
+ * const safeCopy = await CopyFile("safe-copy", {
+ *   src: "data.json",
+ *   dest: "backup/data.json",
+ *   overwrite: false
+ * });
+ */
+export declare const CopyFile: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<CopyFile>, id: string, props: CopyFileProps) => Promise<CopyFile>);

package/lib/fs/copy-file.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import { Resource } from "../resource";
+import { ignore } from "../util/ignore";
+/**
+ * CopyFile Resource
+ *
+ * Copies a file from a source location to a destination location.
+ *
+ * @example
+ * // Copy a file to a new location
+ * const copiedFile = await CopyFile("config-copy", {
+ *   src: "config.json",
+ *   dest: "backup/config.json"
+ * });
+ *
+ * @example
+ * // Copy a file without overwriting if destination exists
+ * const safeCopy = await CopyFile("safe-copy", {
+ *   src: "data.json",
+ *   dest: "backup/data.json",
+ *   overwrite: false
+ * });
+ */
+export const CopyFile = Resource("fs::CopyFile", async function (id, props) {
+    const { src, dest, overwrite = true } = props;
+    if (this.phase === "delete") {
+        // When deleting, remove the destination file
+        await ignore("ENOENT", async () => fs.promises.unlink(dest));
+        return this.destroy();
+    }
+    else {
+        try {
+            // Check if source file exists
+            await fs.promises.access(src, fs.constants.F_OK);
+            // If this is an update and the destination has changed, delete the old file
+            if (this.phase === "update" &&
+                this.output?.dest &&
+                this.output.dest !== dest) {
+                await ignore("ENOENT", async () => fs.promises.unlink(this.output.dest));
+            }
+            // Check if destination file exists
+            const destinationExists = await fs.promises
+                .access(dest, fs.constants.F_OK)
+                .then(() => true)
+                .catch(() => false);
+            // Copy file if destination doesn't exist or overwrite is true
+            if (!destinationExists || overwrite) {
+                await fs.promises.copyFile(src, dest);
+            }
+            return this({
+                src,
+                dest,
+                overwrite,
+                copied: true,
+                createdAt: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error(`Error copying file from ${src} to ${dest}:`, error);
+            throw error;
+        }
+    }
+});

package/lib/fs/file-system-state-store.d.ts

@@ -0,0 +1,17 @@
+import type { Scope } from "../scope";
+import type { State, StateStore } from "../state";
+export declare class FileSystemStateStore implements StateStore {
+    readonly scope: Scope;
+    readonly dir: string;
+    constructor(scope: Scope);
+    init(): Promise<void>;
+    deinit(): Promise<void>;
+    count(): Promise<number>;
+    list(): Promise<string[]>;
+    get(key: string): Promise<State | undefined>;
+    set(key: string, value: State): Promise<void>;
+    delete(key: string): Promise<void>;
+    all(): Promise<Record<string, State>>;
+    getBatch(ids: string[]): Promise<Record<string, State>>;
+    private getPath;
+}

package/lib/fs/file-system-state-store.js

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ignore } from "../util/ignore";
+import { deserialize, serialize } from "../util/serde";
+const stateRootDir = path.join(process.cwd(), ".alchemy");
+export class FileSystemStateStore {
+    scope;
+    dir;
+    constructor(scope) {
+        this.scope = scope;
+        this.dir = path.join(stateRootDir, ...scope.chain);
+    }
+    async init() {
+        await fs.mkdir(stateRootDir, { recursive: true });
+        await fs.mkdir(this.dir, { recursive: true });
+    }
+    async deinit() {
+        await ignore("ENOENT", () => fs.rmdir(this.dir));
+    }
+    async count() {
+        return Object.keys(await this.list()).length;
+    }
+    async list() {
+        try {
+            const files = await fs.readdir(this.dir, {
+                withFileTypes: true,
+            });
+            return files
+                .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".json"))
+                .map((dirent) => dirent.name.replace(/\.json$/, ""))
+                .map((key) => key.replaceAll(":", "/"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async get(key) {
+        try {
+            const content = await fs.readFile(await this.getPath(key), "utf8");
+            const state = (await deserialize(this.scope, JSON.parse(content)));
+            if (state.output === undefined) {
+                state.output = {};
+            }
+            state.output.Scope = this.scope;
+            return state;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async set(key, value) {
+        return fs.writeFile(await this.getPath(key), JSON.stringify(await serialize(this.scope, value), null, 2));
+    }
+    async delete(key) {
+        return fs.unlink(await this.getPath(key));
+    }
+    async all() {
+        return this.getBatch(await this.list());
+    }
+    async getBatch(ids) {
+        return Object.fromEntries((await Promise.all(Array.from(ids).flatMap(async (id) => {
+            const s = await this.get(id);
+            if (s === undefined) {
+                return [];
+            }
+            return [[id, s]];
+        }))).flat());
+    }
+    async getPath(key) {
+        if (key.includes(":")) {
+            throw new Error(`ID cannot include colons: ${key}`);
+        }
+        if (key.includes("/")) {
+            key = key.replaceAll("/", ":");
+        }
+        const file = path.join(this.dir, `${key}.json`);
+        const dir = path.dirname(file);
+        await fs.mkdir(dir, { recursive: true });
+        return file;
+    }
+}

package/lib/fs/file.d.ts

@@ -79,6 +79,19 @@ export interface File extends Resource<"fs::File"> {
  *   path: "logs/app.log",
  *   content: "application log entry"
  * });
+ *
+ * @example
+ * // Update file content and path
+ * let file = await File("config.json", {
+ *   path: "config.json",
+ *   content: '{ "version": "1.0.0" }'
+ * });
+ *
+ * // Later, update the path and content (old file will be removed)
+ * file = await File("config.json", {
+ *   path: "config/config.json",
+ *   content: '{ "version": "1.0.1" }'
+ * });
  */
 export declare const File: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<File>, id: string, props: {
     path: string;

package/lib/fs/file.js

@@ -36,6 +36,19 @@ alchemy.files = async (...args) => {
  *   path: "logs/app.log",
  *   content: "application log entry"
  * });
+ *
+ * @example
+ * // Update file content and path
+ * let file = await File("config.json", {
+ *   path: "config.json",
+ *   content: '{ "version": "1.0.0" }'
+ * });
+ *
+ * // Later, update the path and content (old file will be removed)
+ * file = await File("config.json", {
+ *   path: "config/config.json",
+ *   content: '{ "version": "1.0.1" }'
+ * });
  */
 export const File = Resource("fs::File", async function (id, props) {
     const filePath = props?.path ?? id;
@@ -43,12 +56,18 @@ export const File = Resource("fs::File", async function (id, props) {
         await ignore("ENOENT", async () => fs.promises.unlink(filePath));
         return this.destroy();
     }
-    else {
-        await fs.promises.mkdir(path.dirname(filePath), {
-            recursive: true,
-        });
-        await fs.promises.writeFile(filePath, props.content);
+    else if (this.phase === "update" &&
+        this.output &&
+        this.output.path !== filePath) {
+        // If path has changed, delete the old file
+        console.log(`File: Path changed from ${this.output.path} to ${filePath}, removing old file`);
+        await ignore("ENOENT", async () => fs.promises.unlink(this.output.path));
     }
+    // Create directory and write file
+    await fs.promises.mkdir(path.dirname(filePath), {
+        recursive: true,
+    });
+    await fs.promises.writeFile(filePath, props.content);
     return this({
         path: filePath,
         content: props.content,

package/lib/fs/folder.d.ts

@@ -10,6 +10,16 @@ export interface FolderProps {
      * @default true
      */
     delete?: boolean;
+    /**
+     * Whether to clean the folder during the deletion phase (even if it contains existing files)
+     * @default false
+     */
+    clean?: boolean;
+    /**
+     * Whether to create the folder recursively
+     * @default true
+     */
+    recursive?: boolean;
 }
 /**
  * Base folder resource type

package/lib/fs/folder.js

@@ -28,12 +28,12 @@ export const Folder = Resource("fs::Folder", async function (id, props) {
     if (this.phase === "delete") {
         if (props?.delete !== false) {
             // we just do a best effort attempt
-            await ignore(["ENOENT", "ENOTEMPTY"], async () => fs.promises.rmdir(dirPath));
+            await ignore(["ENOENT", "ENOTEMPTY"], async () => fs.promises.rmdir(dirPath, { recursive: props?.clean ?? false }));
         }
         return this.destroy();
     }
     else {
-        await ignore("EEXIST", async () => fs.promises.mkdir(dirPath, { recursive: true }));
+        await ignore("EEXIST", async () => fs.promises.mkdir(dirPath, { recursive: props?.recursive ?? true }));
     }
     return this({
         path: dirPath,

package/lib/fs/index.d.ts

@@ -1,8 +1,14 @@
+export * from "./copy-file";
 export * from "./file";
 export * from "./file-collection";
 export * from "./file-ref";
+export * from "./file-system-state-store";
 export * from "./folder";
-export * from "./json-file";
-export * from "./text-file";
-export * from "./typescript-file";
-export * from "./yaml-file";
+export * from "./static-astro-file";
+export * from "./static-css-file";
+export * from "./static-html-file";
+export * from "./static-json-file";
+export * from "./static-text-file";
+export * from "./static-typescript-file";
+export * from "./static-vue-file";
+export * from "./static-yaml-file";

package/lib/fs/index.js

@@ -1,8 +1,14 @@
+export * from "./copy-file";
 export * from "./file";
 export * from "./file-collection";
 export * from "./file-ref";
+export * from "./file-system-state-store";
 export * from "./folder";
-export * from "./json-file";
-export * from "./text-file";
-export * from "./typescript-file";
-export * from "./yaml-file";
+export * from "./static-astro-file";
+export * from "./static-css-file";
+export * from "./static-html-file";
+export * from "./static-json-file";
+export * from "./static-text-file";
+export * from "./static-typescript-file";
+export * from "./static-vue-file";
+export * from "./static-yaml-file";