alchemy 0.8.0 → 0.9.0

package/lib/cloudflare/vectorize-metadata-index.js

@@ -0,0 +1,120 @@
+import { Resource } from "../resource";
+import { CloudflareApi, createCloudflareApi, } from "./api";
+import { CloudflareApiError, handleApiError } from "./api-error";
+import { VectorizeIndex } from "./vectorize-index";
+/**
+ * Creates and manages Cloudflare Vectorize Metadata Indexes.
+ *
+ * Vectorize Metadata Indexes enable filtering based on metadata properties when querying vectors.
+ * Each Vectorize Index can have up to 10 metadata indexes.
+ *
+ * @example
+ * // First create a Vectorize Index
+ * const vectorIndex = await VectorizeIndex("documents", {
+ *   name: "documents",
+ *   config: {
+ *     dimensions: 768,
+ *     metric: "cosine"
+ *   }
+ * });
+ *
+ * // Then create a metadata index for the "category" property
+ * const categoryIndex = await VectorizeMetadataIndex("category-index", {
+ *   index: vectorIndex,
+ *   propertyName: "category",
+ *   indexType: "string"
+ * });
+ *
+ * @example
+ * // Create a metadata index for a numeric property
+ * const yearIndex = await VectorizeMetadataIndex("year-index", {
+ *   index: vectorIndex,
+ *   propertyName: "year",
+ *   indexType: "number"
+ * });
+ *
+ * @see https://developers.cloudflare.com/vectorize/
+ */
+export const VectorizeMetadataIndex = Resource("cloudflare::VectorizeMetadataIndex", async function (id, props) {
+    const api = await createCloudflareApi(props);
+    const indexName = props.index.name;
+    const propertyName = props.propertyName;
+    if (this.phase === "delete") {
+        // Delete metadata index
+        try {
+            await deleteMetadataIndex(api, indexName, propertyName);
+        }
+        catch (error) {
+            if (error instanceof CloudflareApiError &&
+                error.status === 400 &&
+                error.message.includes("does not exist")) {
+                // Index doesn't exist, which is what we want
+            }
+            else {
+                throw error;
+            }
+        }
+        return this.destroy();
+    }
+    else if (this.phase === "update") {
+        // Update operation is not supported
+        throw new Error("Updating Vectorize metadata indexes is not supported by the Cloudflare API. " +
+            "To change a metadata index, delete it and create a new one with the desired configuration.");
+    }
+    else {
+        const indexData = await createMetadataIndex(api, indexName, props);
+        return this({
+            id: propertyName, // Use propertyName as ID
+            index: props.index,
+            propertyName: props.propertyName,
+            indexType: props.indexType,
+            accountId: api.accountId,
+            mutationId: indexData.result.mutationId,
+        });
+    }
+});
+/**
+ * Create a new Vectorize metadata index
+ */
+export async function createMetadataIndex(api, indexName, props) {
+    // Create new metadata index
+    const createPayload = {
+        propertyName: props.propertyName,
+        indexType: props.indexType,
+    };
+    const createResponse = await api.post(`/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}/metadata_index/create`, createPayload);
+    if (!createResponse.ok) {
+        return await handleApiError(createResponse, "creating", "Vectorize metadata index", props.propertyName);
+    }
+    return (await createResponse.json());
+}
+/**
+ * Delete a Vectorize metadata index
+ */
+export async function deleteMetadataIndex(api, indexName, propertyName) {
+    const deleteResponse = await api.post(`/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}/metadata_index/delete`, {
+        propertyName,
+    });
+    if (!deleteResponse.ok) {
+        await handleApiError(deleteResponse, "deleting", "Vectorize metadata index", propertyName);
+    }
+}
+/**
+ * List all metadata indexes for a Vectorize index
+ */
+export async function listMetadataIndexes(api, indexName) {
+    const response = await api.get(`/accounts/${api.accountId}/vectorize/v2/indexes/${indexName}/metadata_index/list`);
+    if (response.status === 410) {
+        // Gone
+        return [];
+    }
+    if (!response.ok) {
+        throw new CloudflareApiError(`Failed to list metadata indexes: ${response.statusText}`, response);
+    }
+    const data = (await response.json());
+    if (!data.success) {
+        const errorMessage = data.errors?.[0]?.message || "Unknown error";
+        throw new Error(`Failed to list metadata indexes: ${errorMessage}`);
+    }
+    return data.result.metadataIndexes;
+}

package/lib/cloudflare/vite-site.d.ts

@@ -0,0 +1,39 @@
+import { Assets } from "./assets";
+import type { Bindings } from "./bindings";
+import { Worker } from "./worker";
+export interface ViteSiteProps<B extends Bindings> {
+    /**
+     * The command to run to build the site
+     */
+    command: string;
+    /**
+     * The name of the worker
+     *
+     * @default id
+     */
+    name?: string;
+    /**
+     * The entrypoint to your server
+     *
+     * @default - a simple server that serves static assets is generated
+     */
+    main?: string;
+    /**
+     * The directory containing your static assets
+     */
+    assets: string;
+    /**
+     * The bindings to pass to the worker
+     */
+    bindings?: B;
+    /**
+     * @default process.cwd()
+     */
+    cwd?: string;
+}
+export type ViteSite<B extends Bindings> = Promise<B extends {
+    ASSETS: any;
+} ? never : Worker<B & {
+    ASSETS: Assets;
+}>>;
+export declare function ViteSite<B extends Bindings>(id: string, props: ViteSiteProps<B>): ViteSite<B>;

package/lib/cloudflare/vite-site.js

@@ -0,0 +1,57 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { alchemy } from "../alchemy";
+import { Exec } from "../os";
+import { Assets } from "./assets";
+import { Worker } from "./worker";
+import { WranglerJson } from "./wrangler.json";
+export async function ViteSite(id, props) {
+    if (props.bindings?.ASSETS) {
+        throw new Error("ASSETS binding is reserved for internal use");
+    }
+    // @ts-ignore - we know the types are correct
+    return await alchemy.run(id, async () => {
+        // Create minimal wrangler.jsonc if it doesn't exist
+        // `building the site requires a wrangler.jsonc file to start - so initialize an empty one if it doesn't exist`
+        const cwd = props.cwd || process.cwd();
+        const wranglerPath = path.join(cwd, "wrangler.jsonc");
+        try {
+            await fs.access(wranglerPath);
+        }
+        catch {
+            await fs.writeFile(wranglerPath, JSON.stringify({
+                name: id,
+                main: props.main,
+                compatibility_date: new Date().toISOString().split("T")[0],
+            }, null, 2));
+        }
+        await Exec("build", {
+            command: props.command,
+        });
+        const staticAssets = await Assets("assets", {
+            path: "./dist",
+        });
+        const worker = await Worker("worker", {
+            name: props.name ?? id,
+            entrypoint: props.main,
+            script: props.main
+                ? undefined
+                : `
+export default {
+  async fetch(request, env) {
+    return env.ASSETS.fetch(request);
+  },
+};`,
+            url: true,
+            adopt: true,
+            bindings: {
+                ...props.bindings,
+                ASSETS: staticAssets,
+            },
+        });
+        await WranglerJson("wrangler.jsonc", {
+            worker,
+        });
+        return worker;
+    });
+}

package/lib/cloudflare/worker.js

@@ -353,6 +353,13 @@ async function prepareWorkerMetadata(ctx, oldBindings, props, assetUploadResult)
                 pipeline: binding.name,
             });
         }
+        else if (binding.type === "vectorize") {
+            meta.bindings.push({
+                type: "vectorize",
+                name: bindingName,
+                index_name: binding.name,
+            });
+        }
         else {
             // @ts-expect-error - we should never reach here
             throw new Error(`Unsupported binding type: ${binding.type}`);

package/lib/cloudflare/wrangler.json.d.ts

@@ -114,6 +114,13 @@ export interface WranglerJsonSpec {
         binding: string;
         class_name: string;
     }[];
+    /**
+     * Vectorize index bindings
+     */
+    vectorize_indexes?: {
+        binding: string;
+        index_name: string;
+    }[];
     /**
      * Plain text bindings (vars)
      */

package/lib/cloudflare/wrangler.json.js

@@ -5,7 +5,7 @@ import { Resource } from "../resource";
  */
 export const WranglerJson = Resource("cloudflare::WranglerJson", async function (id, props) {
     // Default path is wrangler.json in current directory
-    const filePath = props.path || "wrangler.json";
+    const filePath = props.path || "wrangler.jsonc";
     if (this.phase === "delete") {
         return this.destroy();
     }
@@ -50,6 +50,7 @@ function processBindings(spec, bindings) {
     const workflows = [];
     const d1Databases = [];
     const queues = [];
+    const vectorizeIndexes = [];
     // Process each binding
     for (const [bindingName, binding] of Object.entries(bindings)) {
         if (typeof binding === "string") {
@@ -120,6 +121,12 @@ function processBindings(spec, bindings) {
                 queue: binding.name,
             });
         }
+        else if (binding.type === "vectorize") {
+            vectorizeIndexes.push({
+                binding: bindingName,
+                index_name: binding.name,
+            });
+        }
     }
     // Add collected bindings to the spec
     if (kvNamespaces.length > 0) {
@@ -139,4 +146,7 @@ function processBindings(spec, bindings) {
     if (queues.length > 0) {
         spec.queues = queues;
     }
+    if (vectorizeIndexes.length > 0) {
+        spec.vectorize_indexes = vectorizeIndexes;
+    }
 }

package/lib/destroy.js

@@ -33,6 +33,14 @@ export async function destroy(...args) {
     if (!instance) {
         return;
     }
+    if (instance.Kind === "alchemy::Scope") {
+        const scope = new Scope({
+            parent: instance.Scope,
+            scopeName: instance.ID,
+        });
+        console.log("Destroying scope", scope.chain.join("/"));
+        return await destroy(scope, options);
+    }
     const Provider = PROVIDERS.get(instance.Kind);
     if (!Provider) {
         throw new Error(`Cannot destroy resource "${instance.FQN}" type ${instance.Kind} - no provider found. You may need to import the provider in your alchemy.config.ts.`);
@@ -66,7 +74,11 @@ export async function destroy(...args) {
         let nestedScope;
         try {
             // BUG: this does not restore persisted scope
-            await alchemy.run(instance.ID, async (scope) => {
+            await alchemy.run(instance.ID, {
+                // TODO(sam): this is an awful hack to differentiate between naked scopes and resources
+                isResource: instance.Kind !== "alchemy::Scope",
+                parent: scope,
+            }, async (scope) => {
                 nestedScope = scope;
                 return await Provider.handler.bind(ctx)(instance.ID, state.props);
             });
@@ -97,7 +109,7 @@ export async function destroy(...args) {
         if (options?.strategy !== "parallel") {
             const sorted = resources.sort((a, b) => b.Seq - a.Seq);
             for (const resource of sorted) {
-                await destroy(resource);
+                await destroy(resource, options);
             }
         }
         else {

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

@@ -3,6 +3,7 @@ import type { State, StateStore } from "../state";
 export declare class FileSystemStateStore implements StateStore {
     readonly scope: Scope;
     readonly dir: string;
+    private initialized;
     constructor(scope: Scope);
     init(): Promise<void>;
     deinit(): Promise<void>;

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

@@ -1,4 +1,4 @@
-import fs from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 import { deserialize, serialize } from "../serde";
 import { ignore } from "../util/ignore";
@@ -6,23 +6,27 @@ const stateRootDir = path.join(process.cwd(), ".alchemy");
 export class FileSystemStateStore {
     scope;
     dir;
+    initialized = false;
     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 });
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        await fs.promises.mkdir(this.dir, { recursive: true });
     }
     async deinit() {
-        await ignore("ENOENT", () => fs.rmdir(this.dir));
+        await ignore("ENOENT", () => fs.promises.rmdir(this.dir));
     }
     async count() {
         return Object.keys(await this.list()).length;
     }
     async list() {
         try {
-            const files = await fs.readdir(this.dir, {
+            const files = await fs.promises.readdir(this.dir, {
                 withFileTypes: true,
             });
             return files
@@ -39,7 +43,7 @@ export class FileSystemStateStore {
     }
     async get(key) {
         try {
-            const content = await fs.readFile(await this.getPath(key), "utf8");
+            const content = await fs.promises.readFile(this.getPath(key), "utf8");
             const state = (await deserialize(this.scope, JSON.parse(content)));
             if (state.output === undefined) {
                 state.output = {};
@@ -55,10 +59,19 @@ export class FileSystemStateStore {
         }
     }
     async set(key, value) {
-        return fs.writeFile(await this.getPath(key), JSON.stringify(await serialize(this.scope, value), null, 2));
+        await this.init();
+        await fs.promises.writeFile(this.getPath(key), JSON.stringify(await serialize(this.scope, value), null, 2));
     }
     async delete(key) {
-        return fs.unlink(await this.getPath(key));
+        try {
+            return await fs.promises.unlink(this.getPath(key));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
     }
     async all() {
         return this.getBatch(await this.list());
@@ -72,16 +85,13 @@ export class FileSystemStateStore {
             return [[id, s]];
         }))).flat());
     }
-    async getPath(key) {
+    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;
+        return path.join(this.dir, `${key}.json`);
     }
 }

package/lib/scope.d.ts

@@ -2,7 +2,7 @@ import type { PendingResource, ResourceID } from "./resource";
 import type { StateStore, StateStoreType } from "./state";
 export type ScopeOptions = {
     appName?: string;
-    stage: string;
+    stage?: string;
     parent?: Scope;
     scopeName?: string;
     password?: string;

package/lib/scope.js

@@ -2,6 +2,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { destroy } from "./destroy";
 import { FileSystemStateStore } from "./fs/file-system-state-store";
 const scopeStorage = new AsyncLocalStorage();
+// TODO: support browser
+const DEFAULT_STAGE = process.env.ALCHEMY_STAGE ?? process.env.USER ?? "dev";
 export class Scope {
     static get() {
         return scopeStorage.getStore();
@@ -24,14 +26,14 @@ export class Scope {
     isErrored = false;
     constructor(options) {
         this.appName = options.appName;
-        this.stage = options.stage;
+        this.stage = options?.stage ?? DEFAULT_STAGE;
         this.scopeName = options.scopeName ?? null;
         this.parent = options.parent ?? Scope.get();
         this.quiet = options.quiet ?? this.parent?.quiet ?? false;
         if (this.parent && !this.scopeName) {
             throw new Error("Scope name is required when creating a child scope");
         }
-        this.password = options.password;
+        this.password = options.password ?? this.parent?.password;
         this.state = options.stateStore
             ? options.stateStore(this)
             : new FileSystemStateStore(this);
@@ -65,6 +67,7 @@ export class Scope {
         await this.state.init?.();
     }
     async deinit() {
+        await this.parent?.state.delete(this.scopeName);
         await this.state.deinit?.();
     }
     fqn(resourceID) {

package/lib/state.d.ts

@@ -1,6 +1,6 @@
 import type { Resource, ResourceProps } from "./resource";
 import type { Scope } from "./scope";
-export interface State<Kind extends string = string, Props extends ResourceProps | undefined = ResourceProps | undefined, Out extends Resource = Resource> {
+export type State<Kind extends string = string, Props extends ResourceProps | undefined = ResourceProps | undefined, Out extends Resource = Resource> = {
     status: `creating` | `created` | `updating` | `updated` | `deleting` | `deleted`;
     kind: Kind;
     id: string;
@@ -10,7 +10,7 @@ export interface State<Kind extends string = string, Props extends ResourceProps
     props: Props;
     oldProps?: Props;
     output: Out;
-}
+};
 export type StateStoreType = (scope: Scope) => StateStore;
 export interface StateStore {
     /** Initialize the state container if one is required */

package/lib/test/bun.d.ts

@@ -1,4 +1,4 @@
-import type { Scope } from "../scope";
+import { Scope } from "../scope";
 import type { StateStoreType } from "../state";
 /**
  * Extend the Alchemy interface to include test functionality
@@ -12,11 +12,6 @@ declare module "../alchemy" {
  * Options for configuring test behavior
  */
 export interface TestOptions {
-    /**
-     * Whether to automatically destroy resources after test.
-     * @default true.
-     */
-    destroy?: boolean;
     /**
      * Whether to suppress logging output.
      * @default false.

package/lib/test/bun.js

@@ -3,7 +3,7 @@ import { afterAll, beforeAll, it } from "bun:test";
 import path from "node:path";
 import { alchemy } from "../alchemy";
 import { R2RestStateStore } from "../cloudflare";
-import { destroy } from "../destroy";
+import { Scope } from "../scope";
 /**
  * Add test functionality to alchemy instance
  */
@@ -32,7 +32,6 @@ alchemy.test = test;
  * ```
  */
 export function test(meta, defaultOptions) {
-    let isFailed = false;
     defaultOptions = defaultOptions ?? {};
     if (defaultOptions.stateStore === undefined &&
         // process.env.CI &&
@@ -52,65 +51,47 @@ export function test(meta, defaultOptions) {
         return test;
     };
     // Create local test scope based on filename
-    const localTestScope = alchemy.scope(`${defaultOptions.prefix ? `${defaultOptions.prefix}-` : ""}${path.basename(meta.filename)}`, {
+    const scope = new Scope({
+        scopeName: `${defaultOptions.prefix ? `${defaultOptions.prefix}-` : ""}${path.basename(meta.filename)}`,
         // parent: globalTestScope,
         stateStore: defaultOptions?.stateStore,
     });
-    test.scope = localTestScope;
     test.beforeAll = (fn) => {
-        return beforeAll(async () => {
-            test.scope.enter();
-            await fn(test.scope);
-        });
+        return beforeAll(() => scope.run(() => fn(scope)));
     };
     test.afterAll = (fn) => {
-        return afterAll(async () => {
-            test.scope.enter();
-            await fn(test.scope);
-        });
+        return afterAll(() => scope.run(() => fn(scope)));
     };
-    // Clean up test scope after all tests complete
-    afterAll(async () => {
-        if (defaultOptions?.destroy !== false && !isFailed) {
-            await alchemy.destroy(test.scope);
-        }
-    });
     return test;
     function test(...args) {
         const testName = args[0];
         const _options = typeof args[1] === "object" ? args[1] : undefined;
+        const timeout = typeof args[args.length - 1] === "number"
+            ? args[args.length - 1]
+            : 120000;
         const spread = (obj) => obj && typeof obj === "object"
             ? Object.fromEntries(Object.entries(obj).flatMap(([k, v]) => v !== undefined ? [[k, v]] : []))
             : {};
         // Merge options with defaults
         const options = {
-            destroy: true,
             quiet: false,
             password: "test-password",
             ...spread(defaultOptions),
             ...spread(_options),
         };
         const fn = typeof args[1] === "function" ? args[1] : args[2];
-        return alchemy.run(testName, {
+        return it(testName, async () => alchemy.run(testName, {
             ...options,
-            parent: localTestScope,
+            parent: scope,
         }, async (scope) => {
-            return it(testName, async () => {
+            try {
                 // Enter test scope since bun calls from different scope
-                scope.enter();
-                try {
-                    await fn(scope);
-                }
-                catch (err) {
-                    console.error(err);
-                    throw err;
-                }
-                finally {
-                    if (options.destroy !== false) {
-                        await destroy(scope);
-                    }
-                }
-            });
-        });
+                await scope.run(() => fn(scope));
+            }
+            catch (err) {
+                console.error(err);
+                throw err;
+            }
+        }), timeout);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {