alchemy 0.1.18 → 0.2.1

package/lib/stripe/price.d.ts

@@ -1,4 +1,6 @@
 import Stripe from "stripe";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 /**
  * Properties for price recurring configuration
  */
@@ -80,7 +82,7 @@ export interface PriceProps {
 /**
  * Output from the Stripe price
  */
-export interface PriceOutput extends PriceProps {
+export interface Price extends Resource<"stripe::Price">, PriceProps {
     /**
      * The ID of the price
      */
@@ -102,8 +104,5 @@ export interface PriceOutput extends PriceProps {
      */
     lookupKey?: string;
 }
-declare const Price_base: import("../resource").Provider<"stripe::Price", [props: PriceProps], PriceOutput>;
-export declare class Price extends Price_base {
-}
+export declare const Price: ((this: Context<Price>, id: string, props: PriceProps) => Promise<Price>) | (((this: any, id: string, props: PriceProps) => never) & (new (_: never) => never));
 export {};
-//# sourceMappingURL=price.d.ts.map

package/lib/stripe/price.js

@@ -1,6 +1,6 @@
 import Stripe from "stripe";
 import { Resource } from "../resource";
-export class Price extends Resource("stripe::Price", async (ctx, props) => {
+export const Price = Resource("stripe::Price", async function (id, props) {
     // Get Stripe API key from context or environment
     const apiKey = process.env.STRIPE_API_KEY;
     if (!apiKey) {
@@ -8,32 +8,25 @@ export class Price extends Resource("stripe::Price", async (ctx, props) => {
     }
     // Initialize Stripe client
     const stripe = new Stripe(apiKey);
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         try {
-            if (ctx.event === "delete" && ctx.output?.id) {
+            if (this.phase === "delete" && this.output?.id) {
                 // Prices can't be deleted, only deactivated
-                await stripe.prices.update(ctx.output.id, { active: false });
+                await stripe.prices.update(this.output.id, { active: false });
             }
         }
         catch (error) {
             // Ignore if the price doesn't exist
             console.error("Error deactivating price:", error);
         }
-        // Return a minimal output for deleted state
-        return {
-            ...props,
-            id: "",
-            createdAt: 0,
-            livemode: false,
-            type: (props.recurring ? "recurring" : "one_time"),
-        };
+        return this.destroy();
     }
     else {
         try {
             let price;
-            if (ctx.event === "update" && ctx.output?.id) {
+            if (this.phase === "update" && this.output?.id) {
                 // Update existing price (limited properties can be updated)
-                price = await stripe.prices.update(ctx.output.id, {
+                price = await stripe.prices.update(this.output.id, {
                     active: props.active,
                     metadata: props.metadata,
                     nickname: props.nickname,
@@ -81,7 +74,7 @@ export class Price extends Resource("stripe::Price", async (ctx, props) => {
                 }
                 : undefined;
             // Map Stripe API response to our output format
-            const output = {
+            return this({
                 id: price.id,
                 product: typeof price.product === "string"
                     ? price.product
@@ -99,14 +92,11 @@ export class Price extends Resource("stripe::Price", async (ctx, props) => {
                 livemode: price.livemode,
                 type: price.type,
                 lookupKey: price.lookup_key || undefined,
-            };
-            return output;
+            });
         }
         catch (error) {
             console.error("Error creating/updating price:", error);
             throw error;
         }
     }
-}) {
-}
-//# sourceMappingURL=price.js.map
+});

package/lib/stripe/product.d.ts

@@ -1,4 +1,6 @@
 import Stripe from "stripe";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 type ProductType = Stripe.Product.Type;
 /**
  * Properties for creating a Stripe product
@@ -52,7 +54,7 @@ export interface ProductProps {
 /**
  * Output from the Stripe product
  */
-export interface ProductOutput extends ProductProps {
+export interface Product extends Resource<"stripe::Product">, ProductProps {
     /**
      * The ID of the product
      */
@@ -79,8 +81,5 @@ export interface ProductOutput extends ProductProps {
         width: number;
     };
 }
-declare const Product_base: import("../resource").Provider<"stripe::Product", [props: ProductProps], ProductOutput>;
-export declare class Product extends Product_base {
-}
+export declare const Product: ((this: Context<Product>, id: string, props: ProductProps) => Promise<Product>) | (((this: any, id: string, props: ProductProps) => never) & (new (_: never) => never));
 export {};
-//# sourceMappingURL=product.d.ts.map

package/lib/stripe/product.js

@@ -1,6 +1,6 @@
 import Stripe from "stripe";
 import { Resource } from "../resource";
-export class Product extends Resource("stripe::Product", async (ctx, props) => {
+export const Product = Resource("stripe::Product", async function (id, props) {
     // Get Stripe API key from context or environment
     const apiKey = process.env.STRIPE_API_KEY;
     if (!apiKey) {
@@ -8,10 +8,10 @@ export class Product extends Resource("stripe::Product", async (ctx, props) => {
     }
     // Initialize Stripe client
     const stripe = new Stripe(apiKey);
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         try {
-            if (ctx.event === "delete" && ctx.output?.id) {
-                await stripe.products.update(ctx.output.id, { active: false });
+            if (this.phase === "delete" && this.output?.id) {
+                await stripe.products.update(this.output.id, { active: false });
             }
         }
         catch (error) {
@@ -19,20 +19,14 @@ export class Product extends Resource("stripe::Product", async (ctx, props) => {
             console.error("Error deactivating product:", error);
         }
         // Return a minimal output for deleted state
-        return {
-            ...props,
-            id: "",
-            createdAt: 0,
-            updatedAt: 0,
-            livemode: false,
-        };
+        return this.destroy();
     }
     else {
         try {
             let product;
-            if (ctx.event === "update" && ctx.output?.id) {
+            if (this.phase === "update" && this.output?.id) {
                 // Update existing product
-                product = await stripe.products.update(ctx.output.id, {
+                product = await stripe.products.update(this.output.id, {
                     name: props.name,
                     description: props.description,
                     active: props.active,
@@ -59,8 +53,7 @@ export class Product extends Resource("stripe::Product", async (ctx, props) => {
                     tax_code: props.taxCode,
                 });
             }
-            // Map Stripe API response to our output format
-            const output = {
+            return this({
                 id: product.id,
                 name: product.name,
                 description: product.description || undefined,
@@ -77,14 +70,11 @@ export class Product extends Resource("stripe::Product", async (ctx, props) => {
                 livemode: product.livemode,
                 updatedAt: product.updated,
                 packageDimensions: product.package_dimensions || undefined,
-            };
-            return output;
+            });
         }
         catch (error) {
             console.error("Error creating/updating product:", error);
             throw error;
         }
     }
-}) {
-}
-//# sourceMappingURL=product.js.map
+});

package/lib/stripe/webhook.d.ts

@@ -1,4 +1,6 @@
 import Stripe from "stripe";
+import type { Context } from "../context";
+import { Resource } from "../resource";
 export type EnabledEvent = Stripe.WebhookEndpointUpdateParams.EnabledEvent;
 /**
  * Properties for creating a Stripe webhook endpoint
@@ -36,7 +38,7 @@ export interface WebhookEndpointProps {
 /**
  * Output from the Stripe webhook endpoint
  */
-export interface WebhookEndpointOutput extends WebhookEndpointProps {
+export interface WebhookEndpoint extends Resource<"stripe::WebhookEndpoint">, WebhookEndpointProps {
     /**
      * The ID of the webhook
      */
@@ -66,8 +68,4 @@ export interface WebhookEndpointOutput extends WebhookEndpointProps {
      */
     status: string;
 }
-declare const WebhookEndpoint_base: import("../resource").Provider<"stripe::WebhookEndpoint", [props: WebhookEndpointProps], WebhookEndpointOutput>;
-export declare class WebhookEndpoint extends WebhookEndpoint_base {
-}
-export {};
-//# sourceMappingURL=webhook.d.ts.map
+export declare const WebhookEndpoint: ((this: Context<WebhookEndpoint>, id: string, props: WebhookEndpointProps) => Promise<WebhookEndpoint>) | (((this: any, id: string, props: WebhookEndpointProps) => never) & (new (_: never) => never));

package/lib/stripe/webhook.js

@@ -1,6 +1,6 @@
 import Stripe from "stripe";
 import { Resource } from "../resource";
-export class WebhookEndpoint extends Resource("stripe::WebhookEndpoint", async (ctx, props) => {
+export const WebhookEndpoint = Resource("stripe::WebhookEndpoint", async function (id, props) {
     // Get Stripe API key from context or environment
     const apiKey = process.env.STRIPE_API_KEY;
     if (!apiKey) {
@@ -8,34 +8,25 @@ export class WebhookEndpoint extends Resource("stripe::WebhookEndpoint", async (
     }
     // Initialize Stripe client
     const stripe = new Stripe(apiKey);
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         try {
             // Get the webhook ID from the stored output
-            if (ctx.event === "delete" && ctx.output?.id) {
-                await stripe.webhookEndpoints.del(ctx.output.id);
+            if (this.phase === "delete" && this.output?.id) {
+                await stripe.webhookEndpoints.del(this.output.id);
             }
         }
         catch (error) {
             // Ignore if the webhook doesn't exist
             console.error("Error deleting webhook:", error);
         }
-        // Return a minimal output for deleted state
-        return {
-            ...props,
-            id: "",
-            secret: "",
-            createdAt: 0,
-            updatedAt: 0,
-            livemode: false,
-            status: "deleted",
-        };
+        return this.destroy();
     }
     else {
         try {
             let webhook;
-            if (ctx.event === "update" && ctx.output?.id) {
+            if (this.phase === "update" && this.output?.id) {
                 // Update existing webhook
-                webhook = await stripe.webhookEndpoints.update(ctx.output.id, {
+                webhook = await stripe.webhookEndpoints.update(this.output.id, {
                     url: props.url,
                     enabled_events: props.enabledEvents,
                     description: props.description,
@@ -62,11 +53,10 @@ export class WebhookEndpoint extends Resource("stripe::WebhookEndpoint", async (
             if (webhook.secret) {
                 secret = webhook.secret;
             }
-            else if (ctx.event === "update" && ctx.output?.secret) {
-                secret = ctx.output.secret;
+            else if (this.phase === "update" && this.output?.secret) {
+                secret = this.output.secret;
             }
-            // Map Stripe API response to our output format
-            const output = {
+            return this({
                 id: webhook.id,
                 url: webhook.url,
                 enabledEvents: webhook.enabled_events,
@@ -81,14 +71,11 @@ export class WebhookEndpoint extends Resource("stripe::WebhookEndpoint", async (
                 livemode: webhook.livemode,
                 updatedAt: webhook.created, // Using created timestamp as updated
                 status: webhook.status,
-            };
-            return output;
+            });
         }
         catch (error) {
             console.error("Error creating/updating webhook:", error);
             throw error;
         }
     }
-}) {
-}
-//# sourceMappingURL=webhook.js.map
+});

package/lib/test/bun.d.ts

@@ -0,0 +1,19 @@
+import type { Scope } from "../scope";
+declare module "../alchemy" {
+    interface Alchemy {
+        test: typeof test;
+    }
+}
+export interface TestOptions {
+    destroy?: boolean;
+    quiet?: boolean;
+    password?: string;
+}
+type test = {
+    (name: string, fn: (scope: Scope) => Promise<any>, timeout?: number): void;
+    (name: string, options: TestOptions, fn: (scope: Scope) => Promise<any>, timeout?: number): void;
+    skipIf(condition: boolean): test;
+    scope: Scope;
+};
+export declare function test(meta: ImportMeta, defaultOptions?: TestOptions): test;
+export {};

package/lib/test/bun.js

@@ -0,0 +1,55 @@
+/// <reference types="bun" />
+import { afterAll, it } from "bun:test";
+import path from "node:path";
+import { alchemy } from "../alchemy";
+import { destroy } from "../destroy";
+alchemy.test = test;
+const globalTestScope = alchemy.scope("test");
+export function test(meta, defaultOptions) {
+    test.skipIf = (condition) => {
+        if (condition) {
+            // TODO: proxy through to bun:test.skipIf
+            return (...args) => { };
+        }
+        return test;
+    };
+    const localTestScope = alchemy.scope(path.basename(meta.filename), {
+        parent: globalTestScope,
+    });
+    test.scope = localTestScope;
+    afterAll(() => alchemy.destroy(test.scope));
+    return test;
+    function test(...args) {
+        const testName = args[0];
+        const _options = typeof args[1] === "object" ? args[1] : undefined;
+        const spread = (obj) => obj && typeof obj === "object"
+            ? Object.fromEntries(Object.entries(obj).flatMap(([k, v]) => v !== undefined ? [[k, v]] : []))
+            : {};
+        const options = {
+            destroy: false,
+            quiet: false,
+            password: "test-password",
+            ...spread(defaultOptions),
+            ...spread(_options),
+        };
+        const fn = typeof args[1] === "function" ? args[1] : args[2];
+        return alchemy.run(testName, {
+            ...options,
+            parent: localTestScope,
+        }, async (scope) => {
+            return it(testName, async () => {
+                // bun will call from a different scope, so we need to enter the test's scope manually
+                scope.enter();
+                try {
+                    await fn(scope);
+                }
+                finally {
+                    if (options.destroy !== false) {
+                        // TODO: auto-destroy resources
+                        await destroy(scope);
+                    }
+                }
+            });
+        });
+    }
+}

package/lib/{utils → util}/content-type.d.ts

@@ -5,4 +5,3 @@
  * @returns The content type for the file
  */
 export declare function getContentType(filePath: string): string;
-//# sourceMappingURL=content-type.d.ts.map

package/lib/{utils → util}/content-type.js

@@ -38,4 +38,3 @@ export function getContentType(filePath) {
     const extension = path.extname(filePath).toLowerCase();
     return mimeTypes[extension] || "application/octet-stream";
 }
-//# sourceMappingURL=content-type.js.map

package/lib/{encrypt.d.ts → util/encrypt.d.ts}

@@ -14,4 +14,3 @@ export declare function encryptWithKey(value: string, key: string): Promise<stri
  * @returns The decrypted string
  */
 export declare function decryptWithKey(encryptedValue: string, key: string): Promise<string>;
-//# sourceMappingURL=encrypt.d.ts.map

package/lib/{encrypt.js → util/encrypt.js}

@@ -42,4 +42,3 @@ export async function decryptWithKey(encryptedValue, key) {
     const decryptedBin = sodium.crypto_secretbox_open_easy(ciphertext, nonce, cryptoKey);
     return sodium.to_string(decryptedBin);
 }
-//# sourceMappingURL=encrypt.js.map

package/lib/{error.d.ts → util/ignore.d.ts}

@@ -1,2 +1 @@
 export declare function ignore<T>(codes: string | string[], fn: () => Promise<T>): Promise<T | undefined>;
-//# sourceMappingURL=error.d.ts.map

package/lib/{error.js → util/ignore.js}

@@ -10,4 +10,3 @@ export async function ignore(codes, fn) {
         throw error;
     }
 }
-//# sourceMappingURL=error.js.map

package/lib/{utils → util}/retry.d.ts

@@ -10,4 +10,3 @@
  * @throws The last error encountered if all retries fail
  */
 export declare function withExponentialBackoff<T>(operation: () => Promise<T>, isRetryable: (error: any) => boolean, maxAttempts?: number, initialDelayMs?: number): Promise<T>;
-//# sourceMappingURL=retry.d.ts.map

package/lib/{utils → util}/retry.js

@@ -29,4 +29,3 @@ export async function withExponentialBackoff(operation, isRetryable, maxAttempts
         }
     }
 }
-//# sourceMappingURL=retry.js.map

package/lib/util/rm.d.ts

@@ -0,0 +1 @@
+export declare function rm(path: string): Promise<void>;

package/lib/util/rm.js

@@ -0,0 +1,11 @@
+import fs from "fs/promises";
+export async function rm(path) {
+    try {
+        await fs.rm(path, { recursive: true, force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}

package/lib/util/serde.d.ts

@@ -0,0 +1,3 @@
+import { Scope } from "../scope";
+export declare function serialize(scope: Scope, value: any): Promise<any>;
+export declare function deserialize(scope: Scope, value: any): Promise<any>;

package/lib/{serde.js → util/serde.js}

@@ -1,37 +1,46 @@
+import { Scope } from "../scope";
+import { Secret } from "../secret";
 import { decryptWithKey, encryptWithKey } from "./encrypt";
-import { Secret, getSecretPassphrase } from "./secret";
-export async function serialize(value) {
+export async function serialize(scope, value) {
     if (Array.isArray(value)) {
-        return Promise.all(value.map(serialize));
+        return Promise.all(value.map((value) => serialize(scope, value)));
     }
     else if (value instanceof Secret) {
+        if (!scope.password) {
+            throw new Error("Cannot serialize secret without password");
+        }
         return {
-            "@secret": await encryptWithKey(value.unencrypted, getSecretPassphrase()),
+            "@secret": await encryptWithKey(value.unencrypted, scope.password),
         };
     }
+    else if (value instanceof Scope) {
+        return undefined;
+    }
     else if (value && typeof value === "object") {
         return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, value]) => [
             key,
-            await serialize(value),
+            await serialize(scope, value),
         ])));
     }
     return value;
 }
-export async function deserialize(value) {
+export async function deserialize(scope, value) {
     if (Array.isArray(value)) {
-        return await Promise.all(value.map(async (item) => await deserialize(item)));
+        return await Promise.all(value.map(async (item) => await deserialize(scope, item)));
     }
     else if (value && typeof value === "object") {
         if (typeof value["@secret"] === "string") {
-            return new Secret(await decryptWithKey(value["@secret"], getSecretPassphrase()));
+            if (!scope.password) {
+                throw new Error("Cannot deserialize secret without password");
+            }
+            return new Secret(await decryptWithKey(value["@secret"], scope.password));
         }
         else {
             return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, value]) => [
                 key,
-                await deserialize(value),
+                await deserialize(scope, value),
             ])));
         }
     }
     return value;
 }
-//# sourceMappingURL=serde.js.map

package/lib/util/slugify.d.ts

@@ -0,0 +1 @@
+export declare function slugify(str: string, delimiter?: string): string;

package/lib/util/slugify.js

@@ -0,0 +1,3 @@
+export function slugify(str, delimiter = "-") {
+    return str.toLowerCase().replace(/[^a-z0-9]/gi, delimiter);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "alchemy",
-  "version": "0.1.18",
+  "version": "0.2.1",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {
-    "publish:npm": "rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish"
+    "publish:npm": "cp ../README.md . && rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && npm publish && rm README.md"
   },
   "files": ["lib", "src"],
   "exports": {
@@ -12,10 +12,12 @@
     "./aws": "./lib/aws/index.js",
     "./aws/oidc": "./lib/aws/oidc/index.js",
     "./cloudflare": "./lib/cloudflare/index.js",
-    "./esbuild": "./lib/esbuild.js",
-    "./fs": "./lib/fs.js",
+    "./esbuild": "./lib/esbuild/index.js",
+    "./fs": "./lib/fs/index.js",
     "./github": "./lib/github/index.js",
-    "./stripe": "./lib/stripe/index.js"
+    "./project": "./lib/project/index.js",
+    "./stripe": "./lib/stripe/index.js",
+    "./test/bun": "./lib/test/bun.js"
   },
   "peerDependencies": {
     "@ai-sdk/openai": "^1.1.9",