alchemy 0.2.2 → 0.2.3

package/lib/alchemy.d.ts

@@ -10,6 +10,7 @@ export interface Alchemy {
     destroy: typeof destroy;
     secret: typeof secret;
     (...parameters: Parameters<typeof scope>): ReturnType<typeof scope>;
+    (template: TemplateStringsArray, ...values: any[]): Promise<string>;
 }
 export interface AlchemyOptions {
     /**

package/lib/alchemy.js

@@ -1,20 +1,91 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import { DestroyedSignal, destroy } from "./destroy";
 import { Scope } from "./scope";
 import { secret } from "./secret";
 // TODO: support browser
 const DEFAULT_STAGE = process.env.ALCHEMY_STAGE ?? process.env.USER ?? "dev";
-function _alchemy(appName, options) {
-    return scope(undefined, {
-        ...options,
-        appName,
-        stage: options.stage,
-    });
+export const alchemy = _alchemy;
+function _alchemy(...args) {
+    if (typeof args[0] === "string") {
+        const [appName, options] = args;
+        return scope(undefined, {
+            ...options,
+            appName,
+            stage: options?.stage,
+        });
+    }
+    else {
+        const [template, ...values] = args;
+        const [, secondLine] = template[0].split("\n");
+        const leadingSpaces = secondLine
+            ? secondLine.match(/^(\s*)/)?.[1]?.length || 0
+            : 0;
+        const indent = " ".repeat(leadingSpaces);
+        return (async () => {
+            const { isFileCollection, isFileRef } = await import("./fs/file");
+            const appendices = {};
+            const stringValues = await Promise.all(values.map(async function resolve(value) {
+                if (typeof value === "string") {
+                    return indent + value;
+                }
+                else if (value instanceof Promise) {
+                    return resolve(await value);
+                }
+                else if (isFileRef(value)) {
+                    if (!(value.path in appendices)) {
+                        appendices[value.path] = await fs.readFile(value.path, "utf-8");
+                    }
+                    return `[${path.basename(value.path)}](${value.path})`;
+                }
+                else if (isFileCollection(value)) {
+                    return Object.entries(value.files)
+                        .map(([filePath, content]) => {
+                        appendices[filePath] = content;
+                        return `[${path.basename(filePath)}](${filePath})`;
+                    })
+                        .join("\n\n");
+                }
+                else if (Array.isArray(value)) {
+                    return (await Promise.all(value.map(async (value, i) => `${i}. ${await resolve(value)}`))).join("\n");
+                }
+                else {
+                    // TODO: support other types
+                    throw new Error(`Unsupported value type: ${JSON.stringify(value)}`);
+                }
+            }));
+            // Construct the string template by joining template parts with interpolated values
+            const lines = template
+                .map((part) => part
+                .split("\n")
+                .map((line) => line.startsWith(indent) ? line.slice(indent.length) : line)
+                .join("\n"))
+                .flatMap((part, i) => i < stringValues.length ? [part, stringValues[i] ?? ""] : [part])
+                .join("")
+                .split("\n");
+            // Collect and sort appendices by file path
+            return [
+                // format the user prompt and trim the first line if it's empty
+                lines.length > 1 && lines[0].replaceAll(" ", "").length === 0
+                    ? lines.slice(1).join("\n")
+                    : lines.join("\n"),
+                // sort appendices by path and include at the end of the prompt
+                Object.entries(appendices)
+                    .sort(([a], [b]) => a.localeCompare(b))
+                    .map(([filePath, content]) => {
+                    const extension = path.extname(filePath).slice(1);
+                    const codeTag = extension ? extension : "";
+                    return `// ${filePath}\n\`\`\`${codeTag}\n${content}\n\`\`\``;
+                })
+                    .join("\n\n"),
+            ].join("\n");
+        })();
+    }
 }
 _alchemy.destroy = destroy;
 _alchemy.run = run;
 _alchemy.scope = scope;
 _alchemy.secret = secret;
-export const alchemy = _alchemy;
 /**
  * Enter a new scope synchronously.
  * @param options
@@ -35,7 +106,7 @@ async function run(...args) {
     const [id, options, fn] = typeof args[1] === "function"
         ? [args[0], undefined, args[1]]
         : args;
-    await using scope = alchemy.scope(id, options);
+    const scope = alchemy.scope(id, options);
     try {
         return await fn.bind(scope)(scope);
     }
@@ -43,6 +114,11 @@ async function run(...args) {
         if (!(error instanceof DestroyedSignal)) {
             scope.fail();
         }
+        else {
+        }
         throw error;
     }
+    finally {
+        await scope.finalize();
+    }
 }

package/lib/apply.d.ts

@@ -3,4 +3,4 @@ export interface ApplyOptions {
     quiet?: boolean;
     alwaysUpdate?: boolean;
 }
-export declare function apply<Out extends Resource>(resource: PendingResource<Out>, props: ResourceProps, options?: ApplyOptions): Promise<Awaited<Out>>;
+export declare function apply<Out extends Resource>(resource: PendingResource<Out>, props: ResourceProps | undefined, options?: ApplyOptions): Promise<Awaited<Out>>;

package/lib/apply.js

@@ -1,11 +1,12 @@
 import { alchemy } from "./alchemy";
 import { context } from "./context";
 import { PROVIDERS, } from "./resource";
+import { Secret } from "./secret";
 import { serialize } from "./util/serde";
 export async function apply(resource, props, options) {
     const scope = resource.Scope;
     try {
-        const quiet = props.quiet ?? scope.quiet;
+        const quiet = props?.quiet ?? scope.quiet;
         await scope.init();
         let state = (await scope.state.get(resource.ID));
         const provider = PROVIDERS.get(resource.Kind);
@@ -35,15 +36,18 @@ export async function apply(resource, props, options) {
         const alwaysUpdate = options?.alwaysUpdate ?? provider.options?.alwaysUpdate ?? false;
         // Skip update if inputs haven't changed and resource is in a stable state
         if (state.status === "created" || state.status === "updated") {
-            if (JSON.stringify(state.props) ===
-                JSON.stringify(await serialize(scope, props)) &&
-                alwaysUpdate !== true) {
+            const oldProps = JSON.stringify(state.props, (_, value) => value instanceof Secret
+                ? {
+                    "@secret": value.unencrypted,
+                }
+                : value, 2);
+            const newProps = JSON.stringify(await serialize(scope, props, {
+                encrypt: false,
+            }), null, 2);
+            if (oldProps === newProps && alwaysUpdate !== true) {
                 if (!quiet) {
                     console.log(`Skip:    "${resource.FQN}" (no changes)`);
                 }
-                // if (resourceState.output !== undefined) {
-                //   resource[Provide](resourceState.output);
-                // }
                 return state.output;
             }
         }
@@ -63,6 +67,7 @@ export async function apply(resource, props, options) {
             id: resource.ID,
             fqn: resource.FQN,
             seq: resource.Seq,
+            props: state.oldProps,
             state,
             replace: () => {
                 if (isReplaced) {
@@ -72,9 +77,7 @@ export async function apply(resource, props, options) {
                 isReplaced = true;
             },
         });
-        const output = await alchemy.run(resource.ID, async () => {
-            return provider.handler.bind(ctx)(resource.ID, props);
-        });
+        const output = await alchemy.run(resource.ID, async () => provider.handler.bind(ctx)(resource.ID, props));
         if (!quiet) {
             console.log(`${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`);
         }

package/lib/aws/bucket.d.ts

@@ -15,4 +15,4 @@ export interface Bucket extends Resource<"s3::Bucket">, BucketProps {
     versioningEnabled?: boolean;
     acl?: string;
 }
-export declare const Bucket: ((this: Context<Bucket>, id: string, props: BucketProps) => Promise<Bucket>) | (((this: any, id: string, props: BucketProps) => never) & (new (_: never) => never));
+export declare const Bucket: ((this: Context<Bucket>, id: string, props: BucketProps) => Promise<Bucket>) | (((this: any, id: string, props?: BucketProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/function.d.ts

@@ -47,4 +47,4 @@ export interface Function extends Resource<"lambda::Function">, FunctionProps {
     signingProfileVersionArn?: string;
     signingJobArn?: string;
 }
-export declare const Function: ((this: Context<Function>, id: string, props: FunctionProps) => Promise<Function>) | (((this: any, id: string, props: FunctionProps) => never) & (new (_: never) => never));
+export declare const Function: ((this: Context<Function>, id: string, props: FunctionProps) => Promise<Function>) | (((this: any, id: string, props?: FunctionProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/oidc/oidc-provider.d.ts

@@ -55,4 +55,4 @@ export interface OIDCProvider extends Resource<"aws::OIDCProvider">, OIDCProvide
 /**
  * Resource for configuring AWS OIDC provider for GitHub Actions
  */
-export declare const OIDCProvider: ((this: Context<OIDCProvider>, id: string, props: OIDCProviderProps) => Promise<OIDCProvider>) | (((this: any, id: string, props: OIDCProviderProps) => never) & (new (_: never) => never));
+export declare const OIDCProvider: ((this: Context<OIDCProvider>, id: string, props: OIDCProviderProps) => Promise<OIDCProvider>) | (((this: any, id: string, props?: OIDCProviderProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/policy-attachment.d.ts

@@ -6,4 +6,4 @@ export interface PolicyAttachmentProps {
 }
 export interface PolicyAttachment extends Resource<"iam::PolicyAttachment">, PolicyAttachmentProps {
 }
-export declare const PolicyAttachment: ((this: Context<PolicyAttachment>, id: string, props: PolicyAttachmentProps) => Promise<PolicyAttachment>) | (((this: any, id: string, props: PolicyAttachmentProps) => never) & (new (_: never) => never));
+export declare const PolicyAttachment: ((this: Context<PolicyAttachment>, id: string, props: PolicyAttachmentProps) => Promise<PolicyAttachment>) | (((this: any, id: string, props?: PolicyAttachmentProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/policy.d.ts

@@ -31,4 +31,4 @@ export interface Policy extends Resource<"iam::Policy">, PolicyProps {
     updateDate: Date;
     isAttachable: boolean;
 }
-export declare const Policy: ((this: Context<Policy>, id: string, props: PolicyProps) => Promise<Policy>) | (((this: any, id: string, props: PolicyProps) => never) & (new (_: never) => never));
+export declare const Policy: ((this: Context<Policy>, id: string, props: PolicyProps) => Promise<Policy>) | (((this: any, id: string, props?: PolicyProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/queue.d.ts

@@ -29,4 +29,4 @@ export interface Queue extends Resource<"sqs::Queue">, QueueProps {
     arn: string;
     url: string;
 }
-export declare const Queue: ((this: Context<Queue>, id: string, props: QueueProps) => Promise<Queue>) | (((this: any, id: string, props: QueueProps) => never) & (new (_: never) => never));
+export declare const Queue: ((this: Context<Queue>, id: string, props: QueueProps) => Promise<Queue>) | (((this: any, id: string, props?: QueueProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/role.d.ts

@@ -21,4 +21,4 @@ export interface Role extends Resource<"iam::Role">, RoleProps {
     roleId: string;
     createDate: Date;
 }
-export declare const Role: ((this: Context<Role>, id: string, props: RoleProps) => Promise<Role>) | (((this: any, id: string, props: RoleProps) => never) & (new (_: never) => never));
+export declare const Role: ((this: Context<Role>, id: string, props: RoleProps) => Promise<Role>) | (((this: any, id: string, props?: RoleProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/ses.d.ts

@@ -66,4 +66,4 @@ export interface SES extends Resource<"aws::SES">, SESProps {
 /**
  * AWS SES resource for creating and configuring Simple Email Service
  */
-export declare const SES: ((this: Context<SES>, id: string, props: SESProps) => Promise<SES>) | (((this: any, id: string, props: SESProps) => never) & (new (_: never) => never));
+export declare const SES: ((this: Context<SES>, id: string, props: SESProps) => Promise<SES>) | (((this: any, id: string, props?: SESProps | undefined) => never) & (new (_: never) => never));

package/lib/aws/table.d.ts

@@ -20,4 +20,4 @@ export interface Table extends Resource<"dynamo::Table">, TableProps {
     streamArn?: string;
     tableId: string;
 }
-export declare const Table: ((this: Context<Table>, id: string, props: TableProps) => Promise<Table>) | (((this: any, id: string, props: TableProps) => never) & (new (_: never) => never));
+export declare const Table: ((this: Context<Table>, id: string, props: TableProps) => Promise<Table>) | (((this: any, id: string, props?: TableProps | undefined) => never) & (new (_: never) => never));

package/lib/cloudflare/bucket.d.ts

@@ -43,4 +43,4 @@ export interface R2Bucket extends Resource<"cloudflare::R2Bucket">, BucketProps
      */
     creationDate: number;
 }
-export declare const R2Bucket: ((this: Context<R2Bucket>, id: string, props: BucketProps) => Promise<R2Bucket>) | (((this: any, id: string, props: BucketProps) => never) & (new (_: never) => never));
+export declare const R2Bucket: ((this: Context<R2Bucket>, id: string, props: BucketProps) => Promise<R2Bucket>) | (((this: any, id: string, props?: BucketProps | undefined) => never) & (new (_: never) => never));

package/lib/cloudflare/kv-namespace.d.ts

@@ -58,4 +58,4 @@ export interface KVNamespace extends Resource<"cloudflare::KVNamespace">, KVName
      */
     modifiedAt: number;
 }
-export declare const KVNamespace: ((this: Context<KVNamespace>, id: string, props: KVNamespaceProps) => Promise<KVNamespace>) | (((this: any, id: string, props: KVNamespaceProps) => never) & (new (_: never) => never));
+export declare const KVNamespace: ((this: Context<KVNamespace>, id: string, props: KVNamespaceProps) => Promise<KVNamespace>) | (((this: any, id: string, props?: KVNamespaceProps | undefined) => never) & (new (_: never) => never));

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

@@ -157,4 +157,4 @@ export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
      */
     routes?: Record<string, string>;
 }
-export declare const StaticSite: ((this: Context<StaticSite>, id: string, props: StaticSiteProps) => Promise<StaticSite>) | (((this: any, id: string, props: StaticSiteProps) => never) & (new (_: never) => never));
+export declare const StaticSite: ((this: Context<StaticSite>, id: string, props: StaticSiteProps) => Promise<StaticSite>) | (((this: any, id: string, props?: StaticSiteProps | undefined) => never) & (new (_: never) => never));

package/lib/cloudflare/worker.d.ts

@@ -105,4 +105,4 @@ export interface Worker<B extends Bindings = Bindings> extends Resource<"cloudfl
         [bindingName in keyof B]: Bound<B[bindingName]>;
     };
 }
-export declare const Worker: (<const B extends Bindings>(this: Context<Worker<NoInfer<B>>>, id: string, props: WorkerProps<B>) => Promise<Worker<B>>) | (((this: any, id: string, props: WorkerProps<Bindings>) => never) & (new (_: never) => never));
+export declare const Worker: (<const B extends Bindings>(this: Context<Worker<NoInfer<B>>>, id: string, props: WorkerProps<B>) => Promise<Worker<B>>) | (((this: any, id: string, props?: WorkerProps<Bindings> | undefined) => never) & (new (_: never) => never));

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

@@ -240,4 +240,4 @@ export interface WranglerJson extends Resource<"cloudflare::WranglerJson">, Wran
 /**
  * Resource for managing wrangler.json configuration files
  */
-export declare const WranglerJson: ((this: Context<WranglerJson>, id: string, props: WranglerJsonProps) => Promise<WranglerJson>) | (((this: any, id: string, props: WranglerJsonProps) => never) & (new (_: never) => never));
+export declare const WranglerJson: ((this: Context<WranglerJson>, id: string, props: WranglerJsonProps) => Promise<WranglerJson>) | (((this: any, id: string, props?: WranglerJsonProps | undefined) => never) & (new (_: never) => never));

package/lib/cloudflare/zone.d.ts

@@ -193,4 +193,4 @@ export interface Zone extends Resource<"cloudflare::Zone"> {
         minTlsVersion: MinTLSVersionValue;
     };
 }
-export declare const Zone: ((this: Context<Zone>, id: string, props: ZoneProps) => Promise<Zone>) | (((this: any, id: string, props: ZoneProps) => never) & (new (_: never) => never));
+export declare const Zone: ((this: Context<Zone>, id: string, props: ZoneProps) => Promise<Zone>) | (((this: any, id: string, props?: ZoneProps | undefined) => never) & (new (_: never) => never));

package/lib/context.d.ts

@@ -1,18 +1,21 @@
 import type { Resource, ResourceFQN, ResourceID, ResourceKind, ResourceProps } from "./resource";
 import type { Scope } from "./scope";
 import type { State } from "./state";
-export type Context<Out extends Resource> = CreateContext<Out> | UpdateContext<Out> | DeleteContext<Out>;
+export type Context<Out extends Resource, Props extends ResourceProps = ResourceProps> = CreateContext<Out> | UpdateContext<Out, Props> | DeleteContext<Out, Props>;
 export interface CreateContext<Out extends Resource> extends BaseContext<Out> {
     phase: "create";
     output?: undefined;
+    props?: undefined;
 }
-export interface UpdateContext<Out extends Resource> extends BaseContext<Out> {
+export interface UpdateContext<Out extends Resource, Props extends ResourceProps = ResourceProps> extends BaseContext<Out> {
     phase: "update";
     output: Out;
+    props: Props;
 }
-export interface DeleteContext<Out extends Resource> extends BaseContext<Out> {
+export interface DeleteContext<Out extends Resource, Props extends ResourceProps = ResourceProps> extends BaseContext<Out> {
     phase: "delete";
     output: Out;
+    props: Props;
 }
 export interface BaseContext<Out extends Resource> {
     quiet: boolean;
@@ -44,15 +47,17 @@ export interface BaseContext<Out extends Resource> {
     /**
      * Create the Resource envelope (with Alchemy + User properties)
      */
+    (id: string, props: Omit<Out, keyof Resource>): Out;
     (props: Omit<Out, keyof Resource>): Out;
 }
-export declare function context<Kind extends string, Props extends ResourceProps, Out extends Resource>({ scope, phase, kind, id, fqn, seq, state, replace, }: {
+export declare function context<Kind extends string, Props extends ResourceProps | undefined, Out extends Resource>({ scope, phase, kind, id, fqn, seq, state, replace, }: {
     scope: Scope;
     phase: "create" | "update" | "delete";
     kind: ResourceKind;
     id: ResourceID;
     fqn: ResourceFQN;
     seq: number;
+    props: Props;
     state: State<Kind, Props, Out>;
     replace: () => void;
 }): Context<Out>;

package/lib/context.js

@@ -1,10 +1,11 @@
 import { DestroyedSignal } from "./destroy";
 export function context({ scope, phase, kind, id, fqn, seq, state, replace, }) {
-    function create(props) {
+    function create(...args) {
+        const [ID, props] = typeof args[0] === "string" ? args : [id, args[0]];
         return {
             ...props,
             Kind: kind,
-            ID: id,
+            ID,
             FQN: fqn,
             Scope: scope,
             Seq: seq,
@@ -17,6 +18,7 @@ export function context({ scope, phase, kind, id, fqn, seq, state, replace, }) {
         fqn: fqn,
         phase,
         output: state.output,
+        props: state.props,
         replace,
         get: (key) => state.data[key],
         set: async (key, value) => {

package/lib/destroy.js

@@ -12,12 +12,13 @@ function isScopeArgs(a) {
  */
 export async function destroy(...args) {
     if (isScopeArgs(args)) {
-        const [scope, options] = args;
-        const strategy = options?.strategy ?? "sequential";
+        const [scope] = args;
+        const options = {
+            strategy: "sequential",
+            ...(args[1] ?? {}),
+        };
         // destroy all active resources
-        await destroy.all(Array.from(scope.resources.values()), {
-            strategy,
-        });
+        await destroy.all(Array.from(scope.resources.values()), options);
         // then detect orphans and destroy them
         const orphans = await scope.state.all();
         await destroy.all(Object.values(orphans).map((orphan) => ({
@@ -45,9 +46,8 @@ export async function destroy(...args) {
         if (!quiet) {
             console.log(`Delete:  "${instance.FQN}"`);
         }
-        const state = (await scope.state.get(instance.ID));
+        const state = await scope.state.get(instance.ID);
         if (state === undefined) {
-            console.warn(`Resource "${instance.FQN}" not found`);
             return;
         }
         const ctx = context({
@@ -57,6 +57,7 @@ export async function destroy(...args) {
             id: instance.ID,
             fqn: instance.FQN,
             seq: instance.Seq,
+            props: state.props,
             state,
             replace: () => {
                 throw new Error("Cannot replace a resource that is being deleted");

package/lib/docs/document.d.ts

@@ -0,0 +1,123 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import type { Secret } from "../secret";
+/**
+ * Base properties for a Document
+ */
+interface BaseDocumentProps {
+    /**
+     * Path to the markdown document
+     */
+    path: string;
+    /**
+     * Base URL for the OpenAI API
+     * @default 'https://api.openai.com/v1'
+     */
+    baseURL?: string;
+}
+/**
+ * Properties for creating a document with static content
+ */
+interface StaticDocumentProps extends BaseDocumentProps {
+    /**
+     * Static content of the document
+     */
+    content: string;
+    /**
+     * Prompt for generating content
+     * @internal This is marked as never to ensure content and prompt are mutually exclusive
+     */
+    prompt?: never;
+    /**
+     * OpenAI API key
+     * @internal This is marked as never since it's not needed for static content
+     */
+    apiKey?: never;
+    /**
+     * Model configuration
+     * @internal This is marked as never since it's not needed for static content
+     */
+    model?: never;
+    /**
+     * Context files
+     * @internal This is marked as never since it's not needed for static content
+     */
+    context?: never;
+}
+/**
+ * Properties for creating a document with AI-generated content
+ */
+interface GeneratedDocumentProps extends BaseDocumentProps {
+    /**
+     * Static content of the document
+     * @internal This is marked as never to ensure content and prompt are mutually exclusive
+     */
+    content?: never;
+    /**
+     * Prompt for generating content
+     * Can be either a single string or an array of strings that will be joined with newlines
+     */
+    prompt: string | string[];
+    /**
+     * Optional context files to include in the prompt
+     * Key is the relative path to the file
+     * Value can be either the content string or another Document resource
+     */
+    context?: {
+        [relativePath: string]: string | Document | {
+            path: string;
+            content: string;
+        };
+    };
+    /**
+     * OpenAI API key to use for generating content
+     * If not provided, will use OPENAI_API_KEY environment variable
+     */
+    apiKey?: Secret;
+    /**
+     * Model configuration
+     */
+    model?: {
+        /**
+         * Model ID to use
+         * @default 'gpt-4o'
+         */
+        id?: string;
+        /**
+         * Model provider name
+         * @default 'openai'
+         */
+        provider?: string;
+        /**
+         * Model-specific options
+         */
+        options?: Record<string, unknown>;
+    };
+}
+/**
+ * Properties for creating or updating a Document
+ * Must provide either static content or a prompt for AI generation
+ */
+export type DocumentProps = StaticDocumentProps | GeneratedDocumentProps;
+/**
+ * A markdown document that can be created, updated, and deleted
+ */
+export interface Document extends Omit<DocumentProps, "content" | "prompt" | "context">, Resource<"docs::Document"> {
+    /**
+     * Content of the document
+     */
+    content: string;
+    /**
+     * Time at which the document was created
+     */
+    createdAt: number;
+    /**
+     * Time at which the document was last updated
+     */
+    updatedAt: number;
+}
+/**
+ * Resource for managing markdown documents using the Vercel AI SDK
+ */
+export declare const Document: ((this: Context<Document, DocumentProps>, id: string, props: DocumentProps) => Promise<Document>) | (((this: any, id: string, props?: DocumentProps | undefined) => never) & (new (_: never) => never));
+export {};

package/lib/docs/document.js

@@ -0,0 +1,67 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { generateText } from "ai";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Resource } from "../resource";
+/**
+ * Resource for managing markdown documents using the Vercel AI SDK
+ */
+export const Document = Resource("docs::Document", async function (id, props) {
+    // Ensure directory exists
+    await fs.mkdir(path.dirname(props.path), { recursive: true });
+    if (this.phase === "delete") {
+        try {
+            await fs.unlink(props.path);
+        }
+        catch (error) {
+            // Ignore if file doesn't exist
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        return this.destroy();
+    }
+    let content;
+    console.log("Generating content for", props.path);
+    // Generate content if prompt is provided
+    if ("prompt" in props) {
+        // Get API key from props or environment
+        const apiKey = props.apiKey?.unencrypted || process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error("OpenAI API key is required for content generation");
+        }
+        // Initialize OpenAI compatible provider
+        const provider = createOpenAICompatible({
+            name: props.model?.provider || "openai",
+            apiKey,
+            baseURL: props.baseURL || "https://api.openai.com/v1",
+        });
+        // Build the full prompt with context if provided
+        const fullPrompt = Array.isArray(props.prompt)
+            ? props.prompt.join("\n")
+            : props.prompt;
+        // console.log(fullPrompt);
+        const { text } = await generateText({
+            model: provider(props.model?.id || "gpt-4o"),
+            prompt: fullPrompt,
+            ...(props.model?.options || {}),
+        });
+        content = text;
+    }
+    else {
+        // Use static content
+        content = props.content;
+    }
+    // Write content to file
+    await fs.writeFile(props.path, content);
+    // Get file stats for timestamps
+    const stats = await fs.stat(props.path);
+    // Return the resource
+    return this({
+        path: props.path,
+        baseURL: props.baseURL,
+        content,
+        createdAt: stats.birthtimeMs,
+        updatedAt: stats.mtimeMs,
+    });
+});

package/lib/docs/index.d.ts

@@ -0,0 +1 @@
+export * from "./document";

package/lib/docs/index.js

@@ -0,0 +1 @@
+export * from "./document";

package/lib/esbuild/bundle.d.ts

@@ -53,7 +53,7 @@ export interface Bundle extends Resource<"esbuild::Bundle"> {
      */
     hash: string;
 }
-export declare const Bundle: ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>) | (((this: any, id: string, props: BundleProps) => never) & (new (_: never) => never));
+export declare const Bundle: ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>) | (((this: any, id: string, props?: BundleProps | undefined) => never) & (new (_: never) => never));
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
     bundle: boolean;
     splitting?: boolean;