@liquidmetal-ai/raindrop 0.0.0

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+// eslint-disable-next-line n/shebang
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/base-command.d.ts

@@ -0,0 +1,27 @@
+import { PromiseClient } from '@connectrpc/connect';
+import { Application } from '@liquidmetal-ai/drizzle/appify/build';
+import { CatalogService } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_connect';
+import { Command, Interfaces } from '@oclif/core';
+import { Config } from './config.js';
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BaseCommand)['baseFlags'] & T['flags']>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    static baseFlags: {};
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    protected raindropConfig?: Config;
+    init(): Promise<void>;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<any>;
+    protected finally(_: Error | undefined): Promise<any>;
+    protected loadConfig(): Promise<Config>;
+    protected saveConfig(config: Config): Promise<void>;
+    protected loadManifest(): Promise<Application[]>;
+    protected catalogService(): Promise<{
+        client: PromiseClient<typeof CatalogService>;
+        userId: string;
+        organizationId: string;
+    }>;
+}
+//# sourceMappingURL=base-command.d.ts.map

package/dist/base-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-command.d.ts","sourceRoot":"","sources":["../src/base-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEnE,OAAO,EAAE,cAAc,EAAE,MAAM,8DAA8D,CAAC;AAE9F,OAAO,EAAE,OAAO,EAAS,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzD,OAAO,EAAE,MAAM,EAA0B,MAAM,aAAa,CAAC;AAG7D,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,OAAO,OAAO,IAAI,UAAU,CAAC,aAAa,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AACvH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,OAAO,OAAO,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEhF,8BAAsB,WAAW,CAAC,CAAC,SAAS,OAAO,OAAO,CAAE,SAAQ,OAAO;IACzE,MAAM,CAAC,SAAS,KAAM;IAEtB,SAAS,CAAC,KAAK,EAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3B,SAAS,CAAC,IAAI,EAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAEzB,SAAS,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAErB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;cAclB,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,GAAG,CAAC;cAKvD,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC;cAI3C,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;cAK7B,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;cAIzC,YAAY,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;cAwBtC,cAAc,IAAI,OAAO,CAAC;QACxC,MAAM,EAAE,aAAa,CAAC,OAAO,cAAc,CAAC,CAAC;QAC7C,MAAM,EAAE,MAAM,CAAC;QACf,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CAIH"}

package/dist/base-command.js

@@ -0,0 +1,69 @@
+import { manifestFromString } from '@liquidmetal-ai/drizzle/appify/index';
+import { CatalogService } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_connect';
+import { RainbowAuthService } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/rainbow_auth_connect';
+import { Command } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig, saveConfig } from './config.js';
+import { createAuthenticatingClient, useClient } from './index.js';
+export class BaseCommand extends Command {
+    static baseFlags = {};
+    flags;
+    args;
+    raindropConfig;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async catch(err) {
+        return super.catch(err);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async finally(_) {
+        return super.finally(_);
+    }
+    async loadConfig() {
+        this.raindropConfig = await loadConfig(this.flags.config);
+        return this.raindropConfig;
+    }
+    async saveConfig(config) {
+        await saveConfig(this.flags.config, config);
+    }
+    async loadManifest() {
+        let manifestPath = this.flags.manifest;
+        if (this.flags.root) {
+            manifestPath = path.isAbsolute(this.flags.manifest)
+                ? this.flags.manifest
+                : path.join(this.flags.root, this.flags.manifest);
+        }
+        const contents = await fs.readFile(manifestPath, 'utf-8');
+        const [apps, errors] = await manifestFromString(contents);
+        const allErrors = errors.some((e) => "severity" in e && e.severity !== 'warning');
+        for (const error of errors) {
+            this.log(`${this.flags.manifest}:${error.line}:${error.column} - ${error.message}`);
+        }
+        if (allErrors && errors.length > 0) {
+            this.error('Manifest loaded with errors', { exit: 1 });
+        }
+        else if (errors.length > 0) {
+            this.warn('Manifest loaded with warnings');
+        }
+        if (apps.length === 0) {
+            this.error('No applications found in manifest', { exit: 1 });
+        }
+        return apps;
+    }
+    async catalogService() {
+        const rainbowAuth = useClient(RainbowAuthService, this.flags.rainbowAuthService);
+        return await createAuthenticatingClient(CatalogService, this.config.configDir, rainbowAuth);
+    }
+}

package/dist/build.d.ts

@@ -0,0 +1,13 @@
+import { Application } from '@liquidmetal-ai/drizzle/appify/build';
+import * as esbuild from 'esbuild';
+export default function build(options: {
+    root: string;
+    entryPoints: string[];
+    outdir: string;
+}): Promise<esbuild.BuildResult>;
+interface Cmd {
+    log: (message?: string, ...args: any[]) => void;
+}
+export declare function buildHandlers(cmd: Cmd, apps: Application[], buildDir: string, root: string): Promise<void>;
+export {};
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAW,MAAM,sCAAsC,CAAC;AAC5E,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAKnC,wBAA8B,KAAK,CAAC,OAAO,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAuD/B;AAED,UAAU,GAAG;IAGX,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACjD;AAGD,wBAAsB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,iBAwChG"}

package/dist/build.js

@@ -0,0 +1,86 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import * as esbuild from 'esbuild';
+import fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { HANDLERS_DIR } from './codegen.js';
+export default async function build(options) {
+    // Customize outbase so that even when only one entryPoint is provided,
+    // the output file is placed in the same directory as it would if
+    // another entryPoint were provided later.
+    let outbase;
+    if (options.entryPoints.length === 1) {
+        outbase = path.join(options.root, HANDLERS_DIR);
+    }
+    const buildResult = await esbuild.build({
+        entryPoints: options.entryPoints,
+        external: ['cloudflare:workers', 'crypto'],
+        bundle: true,
+        outdir: options.outdir,
+        outbase,
+        tsconfig: `${options.root}/tsconfig.json`,
+        // TODO [bosgood] Add support for middleware/code injection from wrangler
+        inject: [],
+        format: 'esm', // Only ES6 module format will be supported
+        sourcemap: true,
+        sourceRoot: options.outdir,
+        // Experiment: let's see how far we can get without minification because:
+        // 1) It should be slightly faster to build
+        // 2) It should be easier to debug
+        minify: false,
+        metafile: true,
+        // From wrangler:
+        target: 'es2022',
+        loader: { '.js': 'jsx', '.mjs': 'jsx', '.cjs': 'jsx' },
+        // Wrangler uses the browser platform for all builds by default,
+        // even when node_compat is enabled.
+        platform: 'browser',
+        // TODO [bosgood] Inlined from wrangler
+        // build conditions used by esbuild, and when resolving custom `import` calls
+        conditions: ['workerd', 'worker', 'browser'],
+        define: {
+            'navigator.userAgent': `"Cloudflare-Workers"`,
+            // TODO [bosgood] wrangler also optionally defines overrides for process.env.NODE_ENV
+        },
+        // The default logLevel is "warning". So that we can rewrite errors before
+        // logging, we disable esbuild's default logging, and log build failures
+        // ourselves.
+        logLevel: 'silent',
+    });
+    return buildResult;
+}
+// Builds the handlers for the given manifest
+export async function buildHandlers(cmd, apps, buildDir, root) {
+    // Wipe out the output directory then rebuild
+    await fs.rm(buildDir, { force: true, recursive: true });
+    cmd.log(`Building to ${buildDir}`);
+    // Discover entrypoints from manifest
+    let entryPoints = [];
+    for (const app of apps) {
+        entryPoints = entryPoints.concat(app.handlers().map((handler) => path.join(root, HANDLERS_DIR, valueOf(handler.name), 'index.ts')));
+    }
+    if (entryPoints.length === 0) {
+        cmd.log('Nothing to build');
+        return;
+    }
+    cmd.log(`Building entry points:\n${entryPoints.join('\n')}`);
+    const buildResult = await build({
+        root: root,
+        entryPoints,
+        outdir: buildDir,
+    });
+    if (buildResult.errors.length > 0 || buildResult.warnings.length > 0) {
+        cmd.log('Build results');
+    }
+    if (buildResult.errors.length > 0) {
+        cmd.log(buildResult.errors.map((e) => e.text).join('\n'));
+    }
+    if (buildResult.warnings.length > 0) {
+        cmd.log(buildResult.warnings.map((w) => w.text).join('\n'));
+    }
+    if (buildResult.errors.length === 0) {
+        cmd.log('Build successful');
+    }
+    else {
+        cmd.log('Build failed', { exit: 1 });
+    }
+}

package/dist/build.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build.test.d.ts.map

package/dist/build.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.test.d.ts","sourceRoot":"","sources":["../src/build.test.ts"],"names":[],"mappings":""}

package/dist/build.test.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from 'vitest';
+import build from './build.js';
+const ENTRY_POINT = `
+console.log('Hello, world!');
+`;
+const TSCONFIG = `
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "isolatedModules": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "jsx": "react-jsx",
+    "outDir": "dist",
+  }
+}
+`;
+test('build', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'build-test'));
+    const srcDir = path.join(root, 'src');
+    await fs.mkdir(srcDir);
+    const tsconfig = path.join(root, 'tsconfig.json');
+    const entryPoint = path.join(root, 'src', 'index.ts');
+    await fs.writeFile(entryPoint, ENTRY_POINT);
+    await fs.writeFile(tsconfig, TSCONFIG);
+    await build({
+        root,
+        entryPoints: [entryPoint],
+        outdir: path.join(root, 'dist'),
+    });
+    expect(await fs.readdir(path.join(root, 'dist'))).toContain('index.js');
+});

package/dist/codegen.d.ts

@@ -0,0 +1,32 @@
+import { Actor, Application, Observer, Service } from '@liquidmetal-ai/drizzle/appify/build';
+export declare const TOOL_NAME = "raindrop build";
+export declare const TEMPLATES_DIR: string;
+export declare const TEMPLATE_INIT = "init";
+export declare const GENERATED_EXTENSION = ".gen";
+export declare const HANDLERS_DIR = "src";
+export declare const RAINDROP_TYPES_FILENAME = "raindrop.gen.ts";
+export declare function trimTemplateSuffix(filename: string): string;
+type TemplateContext = Record<string, string | number>;
+export declare function renderTemplateFromString(template: string, context: TemplateContext): string;
+export declare function renderTemplateFromFile(templatePath: string, context: TemplateContext): Promise<string>;
+export declare function renderTemplatesFromDirectory(templatePath: string, outPath: string, context: TemplateContext, opts: CodegenOptions): Promise<void>;
+export declare function shouldWriteTemplate(opts: CodegenOptions, relPath: string): boolean;
+export type CodegenOptions = {
+    renderScaffoldingCode?: boolean;
+    renderUserModifiableCode?: boolean;
+    renderNonUserModifiableCode?: boolean;
+    overwrite?: boolean;
+} | undefined;
+export declare function renderCodegenPlan(plan: CodegenPlan, outPath: string | undefined, opts: CodegenOptions, context?: TemplateContext): Promise<void>;
+export type CodegenPlan = {
+    templateName: string;
+    outPath: string;
+    context?: TemplateContext;
+}[];
+export declare function codegenPlan(apps: Application[]): CodegenPlan;
+export declare function gatherEnvForHandler(handler: Actor | Service | Observer, app: Application): string;
+export declare function fileExists(path: string): Promise<boolean>;
+export type DirWalkCallback = (relPath: string) => void | Promise<void>;
+export declare function dirWalk(dir: string, visitFn: DirWalkCallback): Promise<void>;
+export {};
+//# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAW,MAAM,sCAAsC,CAAC;AAKtG,eAAO,MAAM,SAAS,mBAAmB,CAAC;AAC1C,eAAO,MAAM,aAAa,QAA6E,CAAC;AACxG,eAAO,MAAM,aAAa,SAAS,CAAC;AACpC,eAAO,MAAM,mBAAmB,SAAS,CAAC;AAC1C,eAAO,MAAM,YAAY,QAAQ,CAAC;AAClC,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAYzD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAEvD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,MAAM,CAG3F;AAED,wBAAsB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAG5G;AAED,wBAAsB,4BAA4B,CAChD,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAqBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAYlF;AAED,MAAM,MAAM,cAAc,GACtB;IACA,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,2BAA2B,CAAC,EAAE,OAAO,CAAC;IAEtC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GACC,SAAS,CAAC;AAEd,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,MAAM,GAAG,SAAqB,EACvC,IAAI,EAAE,cAAc,EACpB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B,EAAE,CAAC;AAGJ,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,CAsC5D;AAeD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,MAAM,CAoDjG;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO/D;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAGxE,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAalF"}

package/dist/codegen.js

@@ -0,0 +1,212 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import Handlebars from 'handlebars';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const TOOL_NAME = 'raindrop build';
+export const TEMPLATES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'templates');
+export const TEMPLATE_INIT = 'init';
+export const GENERATED_EXTENSION = '.gen';
+export const HANDLERS_DIR = 'src';
+export const RAINDROP_TYPES_FILENAME = 'raindrop.gen.ts';
+const TEMPLATE_R2_EVENT_NOTIFICATION = path.join('handlers', 'r2-event-notification');
+const TEMPLATE_QUEUE_CONSUMER = path.join('handlers', 'queue-consumer');
+const TEMPLATE_HTTP_SERVICE = path.join('handlers', 'http-service');
+const TEMPLATE_ACTOR = path.join('handlers', 'actor');
+const TEMPLATE_EXTENSION = '.hbs';
+const SCAFFOLDING_PREFIX = '__';
+const HANDLEBARS_RENDER_OPTS = {
+    strict: true, // Fail on missing variables
+    noEscape: true, // Do not escape HTML
+};
+export function trimTemplateSuffix(filename) {
+    return filename.replace(new RegExp(`${TEMPLATE_EXTENSION}$`), '');
+}
+export function renderTemplateFromString(template, context) {
+    const compiledTemplate = Handlebars.compile(template, HANDLEBARS_RENDER_OPTS);
+    return compiledTemplate(context);
+}
+export async function renderTemplateFromFile(templatePath, context) {
+    const template = await fs.readFile(templatePath, 'utf-8');
+    return renderTemplateFromString(template, context);
+}
+export async function renderTemplatesFromDirectory(templatePath, outPath, context, opts) {
+    const visit = async (relPath) => {
+        if (!shouldWriteTemplate(opts, relPath)) {
+            return;
+        }
+        const rawContent = await fs.readFile(path.join(templatePath, relPath), 'utf-8');
+        // Templates are rendered, other files are copied
+        const content = relPath.endsWith(TEMPLATE_EXTENSION)
+            ? await renderTemplateFromFile(path.join(templatePath, relPath), context)
+            : rawContent;
+        const outputFilename = trimTemplateSuffix(relPath);
+        await fs.mkdir(path.join(outPath, path.dirname(outputFilename)), { recursive: true });
+        const outputFilePath = path.join(outPath, outputFilename);
+        const alreadyExists = await fileExists(outputFilePath);
+        if (alreadyExists && !opts?.overwrite) {
+            return;
+        }
+        await fs.writeFile(outputFilePath, content);
+    };
+    return await dirWalk(templatePath, visit);
+}
+function templateType(relPath) {
+    if (path.basename(relPath).startsWith(SCAFFOLDING_PREFIX)) {
+        return 'scaffolding';
+    }
+    if (path.basename(relPath).includes(GENERATED_EXTENSION)) {
+        return 'non-user-modifiable';
+    }
+    return 'user-modifiable';
+}
+export function shouldWriteTemplate(opts, relPath) {
+    const type = templateType(relPath);
+    if (type == 'scaffolding' && !opts?.renderScaffoldingCode) {
+        return false;
+    }
+    if (type == 'non-user-modifiable' && !opts?.renderNonUserModifiableCode) {
+        return false;
+    }
+    if (!['scaffolding', 'non-user-modifiable'].includes(type) && !opts?.renderUserModifiableCode) {
+        return false;
+    }
+    return true;
+}
+export async function renderCodegenPlan(plan, outPath = undefined, opts, context = {}) {
+    const templateContext = {
+        ...context,
+        toolName: TOOL_NAME,
+    };
+    for (const task of plan) {
+        await renderTemplatesFromDirectory(task.templateName, outPath ? path.join(outPath, task.outPath) : task.outPath, { ...templateContext, ...task.context }, opts);
+    }
+}
+// Creates a list of codegen tasks based on the app configuration
+export function codegenPlan(apps) {
+    const plan = [];
+    // Initialization template is always included
+    plan.push({
+        templateName: path.join(TEMPLATES_DIR, TEMPLATE_INIT),
+        outPath: '',
+    });
+    for (const app of apps) {
+        for (const observer of app.observer) {
+            // Technically HCL is allowing multiple sources. This may or may not be something we want to support
+            // for raindrop build, but for now let's codegen only on the first available source
+            const primeSource = observer.source[0];
+            const templateName = primeSource?.bucket ? TEMPLATE_R2_EVENT_NOTIFICATION : TEMPLATE_QUEUE_CONSUMER;
+            plan.push({
+                templateName: path.join(TEMPLATES_DIR, templateName),
+                outPath: path.join(HANDLERS_DIR, valueOf(observer.name)),
+                context: { observerName: valueOf(observer.name) },
+            });
+        }
+        for (const service of app.service) {
+            plan.push({
+                templateName: path.join(TEMPLATES_DIR, TEMPLATE_HTTP_SERVICE),
+                outPath: path.join(HANDLERS_DIR, valueOf(service.name)),
+                context: { serviceName: valueOf(service.name) },
+            });
+        }
+        for (const actor of app.actor) {
+            plan.push({
+                templateName: path.join(TEMPLATES_DIR, TEMPLATE_ACTOR),
+                outPath: path.join(HANDLERS_DIR, valueOf(actor.name)),
+                context: { actorClassName: kebabCaseToCamelCase(valueOf(actor.name)) },
+            });
+        }
+    }
+    return plan;
+}
+const TYPE_DEFINITIONS_TEMPLATE = Handlebars.compile(`// Code generated by {{ toolName }}, DO NOT EDIT.
+export interface Env {
+  {{#each resources}}
+  {{this.name}}: {{{this.type}}};
+  {{/each}}
+}
+`, HANDLEBARS_RENDER_OPTS);
+// gatherEnvForHandler gathers up the entire environment mapping for
+// the Env object on the handler.
+export function gatherEnvForHandler(handler, app) {
+    const bindings = {};
+    // Iterate over the entire app and gather all the bindings.
+    for (const appService of app.service) {
+        if (appService !== handler) {
+            bindings[kebabCaseToConstantCase(valueOf(appService.name))] = `import('../${valueOf(appService.name)}').default`;
+        }
+    }
+    for (const appActor of app.actor) {
+        const actorName = valueOf(appActor.name);
+        const actorClass = kebabCaseToCamelCase(actorName);
+        if (appActor === handler) {
+            bindings[kebabCaseToConstantCase(valueOf(appActor.name))] = `DurableObjectNamespace<import('./index.js').${actorClass}>`;
+        }
+        else {
+            bindings[kebabCaseToConstantCase(valueOf(appActor.name))] = `DurableObjectNamespace<import('../${actorName}').${actorClass}>`;
+        }
+    }
+    for (const appObserver of app.observer) {
+        // Don't allow self-queueing.
+        if (appObserver === handler) {
+            continue;
+        }
+        for (const source of appObserver.source) {
+            // Only bind queue sources, not bucket sources.
+            if (source.queue) {
+                bindings[kebabCaseToConstantCase(valueOf(source.queue))] = `Queue<import('../${valueOf(appObserver.name)}').Body>`;
+            }
+        }
+    }
+    for (const appBucket of app.bucket) {
+        bindings[kebabCaseToConstantCase(valueOf(appBucket.name))] = 'R2Bucket';
+    }
+    for (const appSqlDatabase of app.sqlDatabase) {
+        bindings[kebabCaseToConstantCase(valueOf(appSqlDatabase.name))] = 'D1Database';
+    }
+    for (const appVectorizeIndex of app.vectorIndex) {
+        bindings[kebabCaseToConstantCase(valueOf(appVectorizeIndex.name))] = 'VectorizeIndex';
+    }
+    for (const env of app.env) {
+        bindings[kebabCaseToConstantCase(valueOf(env.name))] = 'string';
+    }
+    for (const env of handler.env) {
+        bindings[kebabCaseToConstantCase(valueOf(env.name))] = 'string';
+    }
+    bindings['AI'] = 'Ai';
+    return TYPE_DEFINITIONS_TEMPLATE({
+        toolName: TOOL_NAME,
+        resources: Object.entries(bindings)
+            .map(([name, type]) => ({ name, type }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+    });
+}
+export async function fileExists(path) {
+    try {
+        await fs.lstat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// dirWalk walks a directory tree and calls the callback for each file it encounters
+export async function dirWalk(dir, visitFn) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const tasks = entries.map(async (entry) => {
+        if (entry.isDirectory()) {
+            await dirWalk(path.join(dir, entry.name), visitFn);
+        }
+        else {
+            // Process encountered file
+            await visitFn(entry.name);
+        }
+    });
+    await Promise.all(tasks);
+}
+function kebabCaseToConstantCase(s) {
+    return s.toUpperCase().replace(/-/g, '_');
+}
+function kebabCaseToCamelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}

package/dist/codegen.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codegen.test.d.ts.map

package/dist/codegen.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.test.d.ts","sourceRoot":"","sources":["../src/codegen.test.ts"],"names":[],"mappings":""}

package/dist/codegen.test.js

@@ -0,0 +1,97 @@
+import { mustManifestFromString } from '@liquidmetal-ai/drizzle/appify/index';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from 'vitest';
+import { codegenPlan, renderTemplatesFromDirectory, shouldWriteTemplate, trimTemplateSuffix, } from './codegen.js';
+test('trims handlebars suffix', async () => {
+    expect(trimTemplateSuffix('index.ts.hbs')).toEqual('index.ts');
+});
+test('codegens from blank app', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {}
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(1);
+    expect(plan[0]?.templateName).toMatch('templates/init');
+    expect(plan[0]?.outPath).toEqual('');
+});
+test('codegens from app with observer', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      bucket "bucket" {}
+
+      observer "process" {
+        source {
+          bucket = "bucket"
+        }
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/r2-event-notification');
+    expect(plan[1]?.outPath).toEqual('src/process');
+});
+test('codegens from app with service', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      bucket "bucket" {}
+
+      service "ingester" {
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/http-service');
+    expect(plan[1]?.outPath).toEqual('src/ingester');
+});
+test('codegens from app with durable object', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      actor "ingest-object" {
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/actor');
+    expect(plan[1]?.outPath).toEqual('src/ingest-object');
+});
+test('only codegens scaffolding when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderScaffoldingCode: true,
+    }, 'src/handlers/something/__index.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderScaffoldingCode: false,
+    }, 'src/handlers/something/__index.ts')).toBe(false);
+});
+test('only codegens user modifiable code when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderUserModifiableCode: true,
+    }, 'src/handlers/something/index.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderUserModifiableCode: false,
+    }, 'src/handlers/something/index.ts')).toBe(false);
+});
+test('only codegens non-user modifiable code when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderNonUserModifiableCode: true,
+    }, 'src/handlers/something/env.gen.d.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderNonUserModifiableCode: false,
+    }, 'src/handlers/something/env.gen.d.ts')).toBe(false);
+});
+test('codegens template files', async () => {
+    const templatePath = path.join(__dirname, '..', 'templates', 'init');
+    const outPath = await fs.mkdtemp(path.join(os.tmpdir(), 'codegen-test'));
+    await renderTemplatesFromDirectory(templatePath, outPath, {
+        toolName: 'raindrop',
+        applicationName: 'test-app',
+    }, {
+        renderScaffoldingCode: true,
+        renderUserModifiableCode: true,
+        renderNonUserModifiableCode: true,
+    });
+});

package/dist/commands/auth/list.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../base-command.js';
+export default class List extends BaseCommand<typeof List> {
+    static args: {};
+    static description: string;
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/auth/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/auth/list.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,WAAW,CAAC,OAAO,IAAI,CAAC;IACxD,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAA0B;IAE5C,MAAM,CAAC,KAAK;;MAOV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAmD3B"}