@swell/cli 2.9.0 → 2.9.3

package/dist/lib/apps/app-config.js

@@ -3,7 +3,8 @@ import isEmpty from 'lodash/isEmpty.js';
 import { detectFilenameMime } from 'mime-detect';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { bundleFunction, bundleComponent } from '../bundle.js';
+import { bundleFunction, bundleComponent, bundleWorkflow } from '../bundle.js';
+import { analyzeFunctionSource, hasKindDiagnostic, workflowStaticConfigError, } from '../function-source-analysis.js';
 import { AllConfigPaths, ConfigType, filePathExists, hashFile, } from './index.js';
 export class IgnoringFileError extends Error {
     constructor(message) {
@@ -257,10 +258,32 @@ export class AppConfigFunction extends AppConfig {
                 if (!fileData) {
                     return;
                 }
-                const { code, config } = await bundleFunction(this.filePath);
+                const analysis = await analyzeFunctionSource(this.appPath);
+                if (analysis.kind === 'workflow') {
+                    if (analysis.diagnostics.length > 0) {
+                        throw new Error(analysis.diagnostics.join('\n'));
+                    }
+                    const { code, config } = await bundleWorkflow(this.appPath, analysis);
+                    postData.file = {
+                        data: fileData,
+                    };
+                    postData.build_file = {
+                        content_type: 'application/javascript+module',
+                        data: code,
+                    };
+                    postData.values = config;
+                    return postData;
+                }
+                if (hasKindDiagnostic(analysis)) {
+                    throw new Error(analysis.diagnostics.join('\n'));
+                }
+                const { code, config } = await bundleFunction(this.appPath);
                 if (!config) {
                     throw new IgnoringFileError('Function must export a `config` object.');
                 }
+                if (config.kind === 'workflow') {
+                    throw workflowStaticConfigError();
+                }
                 // Save the original file and the bundled version
                 postData.file = {
                     data: fileData,

package/dist/lib/apps/index.js

@@ -354,8 +354,11 @@ export function appAssetImage(appPath, fileName) {
         }
     }
 }
+function getNameFromFilePath(filePath) {
+    return path.parse(filePath).name.replaceAll('_', '-');
+}
 export function appConfigFromFile(filePath, configType, appPath) {
-    const { name } = path.parse(filePath);
+    const name = getNameFromFilePath(filePath);
     // Notification basenames must not contain dots: the inspect identifier
     // grammar (app.<slug>.<model>.<name>) splits on '.', so a dotted name
     // would silently misparse on lookup.
@@ -376,7 +379,7 @@ export function appConfigFromFile(filePath, configType, appPath) {
     return config;
 }
 export function findAppConfig(app, filePath, configType) {
-    const { name } = path.parse(filePath);
+    const name = getNameFromFilePath(filePath);
     const config = app?.configs?.find((c) => c && c.type === configType && c.name === name);
     return config;
 }

package/dist/lib/bundle.d.ts

@@ -1,2 +1,4 @@
+import type { FunctionSourceAnalysis } from './function-source-analysis.js';
 export declare function bundleFunction(filePath: string): Promise<any>;
+export declare function bundleWorkflow(filePath: string, analysis: FunctionSourceAnalysis): Promise<any>;
 export declare function bundleComponent(filePath: string): Promise<any>;

package/dist/lib/bundle.js

@@ -36,6 +36,32 @@ export async function bundleFunction(filePath) {
         throw new Error(`Unable to compile function ${filePath}: ${error.message}`);
     }
 }
+export async function bundleWorkflow(filePath, analysis) {
+    try {
+        const entrySource = getSwellWorkflowEntrypoint(filePath);
+        const buildResult = await esbuild.build({
+            bundle: true,
+            stdin: {
+                contents: entrySource,
+                loader: 'js',
+                resolveDir: path.dirname(filePath),
+            },
+            external: ['cloudflare:workers', 'cloudflare:workflows'],
+            format: 'esm',
+            metafile: true,
+            platform: 'browser',
+            target: ['es2022'],
+            write: false,
+            logLevel: 'silent',
+        });
+        const { metafile: { inputs }, outputFiles: [{ text: code }], } = buildResult;
+        const dependencies = Object.keys(inputs).filter((input) => !input.startsWith('node_modules/'));
+        return { code, config: analysis.config, dependencies };
+    }
+    catch (error) {
+        throw new Error(`Unable to compile workflow ${filePath}: ${error.message}`);
+    }
+}
 export async function bundleComponent(filePath) {
     try {
         const content = fs.readFileSync(filePath, 'utf8');
@@ -80,6 +106,292 @@ function getSwellFunctionWrapper() {
     const __dirname = path.dirname(__filename);
     return fs.readFileSync(path.join(__dirname, './swell-function-wrapper.js'), 'utf8');
 }
+function getSwellWorkflowEntrypoint(filePath) {
+    const workflowImport = `./${path.basename(filePath)}`;
+    return `
+import { WorkflowEntrypoint } from 'cloudflare:workers';
+import { NonRetryableError } from 'cloudflare:workflows';
+import UserWorkflow from ${JSON.stringify(workflowImport)};
+
+const RUNTIME_PROXY_PATH = '/:workflows/runtime/request';
+const RUNTIME_TOKEN_PATTERN = /\\bwf_rt_[0-9A-Za-z]+_[0-9A-Za-z]{12,}\\b/g;
+
+class SwellWorkflowError extends Error {
+  constructor(body) {
+    const error = body && body.error ? body.error : body;
+    super(error && error.message ? error.message : 'Workflow runtime request failed');
+    this.name = 'SwellError';
+    this.body = body;
+    this.code = error && error.code;
+    this.status = error && error.status;
+    this.retryable = Boolean(error && error.retryable);
+    this.category = error && error.category;
+  }
+}
+
+export class SwellWorkflowEntrypoint extends WorkflowEntrypoint {
+  async run(event, step) {
+    const invocation = getInvocation(event);
+    const runtime = invocation.runtime;
+    const runtimeToken = invocation.runtime_token;
+    const startedAt = Date.now();
+    const proxy = new SwellWorkflowRuntimeProxy(runtime, runtimeToken);
+    const workflow = new UserWorkflow();
+    const req = buildWorkflowRequest(invocation, proxy);
+    const workflowStep = buildWorkflowStep(step, proxy);
+
+    await proxy.log({ phase: 'run', status: 'started' });
+
+    try {
+      const result = await workflow.run(req, workflowStep);
+      await proxy.log({ phase: 'run', status: 'completed', time: Date.now() - startedAt });
+      await proxy.lifecycle('completed');
+      return result;
+    } catch (error) {
+      await proxy.log({
+        phase: 'run',
+        status: 'failed',
+        time: Date.now() - startedAt,
+        error: formatError(error),
+      });
+
+      try {
+        await proxy.lifecycle('failed', formatError(error));
+      } catch (closeoutError) {
+        await proxy.log({
+          phase: 'lifecycle',
+          status: 'failed',
+          error: formatError(closeoutError),
+        });
+      }
+
+      throw error;
+    }
+  }
+}
+
+function getInvocation(event) {
+  const payload = event && Object.prototype.hasOwnProperty.call(event, 'payload')
+    ? event.payload
+    : event;
+
+  if (!payload || typeof payload !== 'object') {
+    throw new Error('Workflow invocation payload is required');
+  }
+
+  if (!payload.runtime || !payload.runtime_token) {
+    throw new Error('Workflow runtime identity is required');
+  }
+
+  return payload;
+}
+
+function buildWorkflowRequest(invocation, proxy) {
+  const runtime = invocation.runtime;
+
+  return {
+    id: runtime.request_id,
+    appId: runtime.app_slug || runtime.app_id,
+    store: {
+      id: runtime.store_id,
+    },
+    data: invocation.data,
+    workflow: {
+      workflow_id: runtime.workflow_id,
+      workflow_name: runtime.workflow_name,
+      workflow_instance_id: runtime.workflow_instance_id,
+      trigger: runtime.trigger,
+      request_id: runtime.request_id,
+    },
+    isLocalDev: false,
+    swell: {
+      get: (path, data) => proxy.api('get', path, data),
+      post: (path, data) => proxy.api('post', path, data),
+      put: (path, data) => proxy.api('put', path, data),
+      delete: (path, data) => proxy.api('delete', path, data),
+      settings: () => proxy.settings(),
+    },
+  };
+}
+
+function buildWorkflowStep(cloudflareStep, proxy) {
+  return Object.freeze({
+    do(name, optionsOrCallback, maybeCallback) {
+      const hasOptions = typeof optionsOrCallback !== 'function';
+      const options = hasOptions ? optionsOrCallback : undefined;
+      const callback = hasOptions ? maybeCallback : optionsOrCallback;
+
+      const wrappedCallback = async () => {
+        await proxy.log({ phase: 'step', step_name: name, status: 'started' });
+
+        try {
+          const result = await callback();
+          await proxy.log({ phase: 'step', step_name: name, status: 'completed' });
+          return result;
+        } catch (error) {
+          await proxy.log({
+            phase: 'step',
+            step_name: name,
+            status: 'failed',
+            error: formatError(error),
+          });
+          throw error;
+        }
+      };
+
+      return hasOptions
+        ? cloudflareStep.do(name, options, wrappedCallback)
+        : cloudflareStep.do(name, wrappedCallback);
+    },
+
+    sleep(name, duration) {
+      return cloudflareStep.sleep(name, duration);
+    },
+
+    sleepUntil(name, date) {
+      return cloudflareStep.sleepUntil(name, date);
+    },
+  });
+}
+
+class SwellWorkflowRuntimeProxy {
+  constructor(runtime, runtimeToken) {
+    this.runtime = runtime;
+    this.runtimeToken = runtimeToken;
+    this.apiHost = getRuntimeApiHost(runtime);
+  }
+
+  api(method, path, data) {
+    return this.request({
+      type: 'api',
+      method,
+      path,
+      data,
+    });
+  }
+
+  settings() {
+    return this.request({
+      type: 'settings',
+    });
+  }
+
+  lifecycle(status, error) {
+    return this.request({
+      type: 'lifecycle',
+      status,
+      error,
+    });
+  }
+
+  async log(entry) {
+    try {
+      return await this.request({
+        type: 'workflow_log',
+        entries: [sanitizeLogEntry(entry)],
+      });
+    } catch {
+      return undefined;
+    }
+  }
+
+  async request(operation) {
+    const response = await fetch(\`\${this.apiHost}\${RUNTIME_PROXY_PATH}\`, {
+      method: 'POST',
+      headers: {
+        Authorization: \`Bearer \${this.runtimeToken}\`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'swell-workflows/1.0',
+      },
+      body: JSON.stringify({
+        runtime: runtimeIdentity(this.runtime),
+        operation,
+      }),
+    });
+    const text = await response.text();
+    const body = parseJson(text);
+
+    if (!response.ok) {
+      throw mapRuntimeError(body, response.status);
+    }
+
+    return body;
+  }
+}
+
+function getRuntimeApiHost(runtime) {
+  const apiHost = runtime && runtime.api_host;
+
+  if (!apiHost || typeof apiHost !== 'string') {
+    throw new Error('Workflow runtime API host is required');
+  }
+
+  if (!/^https?:\\/\\//.test(apiHost)) {
+    throw new Error('Workflow runtime API host must be an HTTP URL');
+  }
+
+  return apiHost.replace(/\\/$/, '');
+}
+
+function runtimeIdentity(runtime) {
+  return {
+    app_id: runtime.app_id,
+    store_id: runtime.store_id,
+    environment_id: runtime.environment_id || null,
+    workflow_id: runtime.workflow_id,
+    workflow_name: runtime.workflow_name,
+    workflow_instance_id: runtime.workflow_instance_id,
+  };
+}
+
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function mapRuntimeError(body, status) {
+  const error = body && body.error ? body.error : {};
+  const runtimeError = new SwellWorkflowError({
+    error: {
+      ...error,
+      status: error.status || status,
+    },
+  });
+
+  if (error.retryable === false) {
+    return new NonRetryableError(runtimeError.message);
+  }
+
+  return runtimeError;
+}
+
+function sanitizeLogEntry(entry) {
+  return {
+    ...entry,
+    error: entry && entry.error ? formatError(entry.error) : undefined,
+  };
+}
+
+function formatError(error) {
+  if (!error) {
+    return undefined;
+  }
+
+  const code = error.code ? String(error.code).replace(RUNTIME_TOKEN_PATTERN, '[redacted]') : undefined;
+  const message = String(error.message || error)
+    .replace(RUNTIME_TOKEN_PATTERN, '[redacted]')
+    .slice(0, 1000);
+
+  return {
+    code,
+    message,
+  };
+}
+`;
+}
 async function minifyCode(code) {
     try {
         const result = await esbuild.transform(code, {

package/dist/lib/create/function.d.ts

@@ -1,4 +1,4 @@
-type FunctionType = 'cron' | 'model' | 'route';
+type FunctionType = 'cron' | 'model' | 'route' | 'workflow';
 type FunctionLanguage = 'js' | 'ts';
 interface CreateFunctionArgs {
     functionName: string;
@@ -14,5 +14,5 @@ interface WriteFunctionFileParams {
     schedule: string;
     trigger: FunctionType;
 }
-declare const getFunctionTemplate: ({ description, events, extension, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
+declare const getFunctionTemplate: ({ description, events, extension, functionName, language, route, schedule, trigger, }: WriteFunctionFileParams) => string;
 export { CreateFunctionArgs, FunctionLanguage, FunctionType, WriteFunctionFileParams, getFunctionTemplate, };

package/dist/lib/create/function.js

@@ -1,4 +1,11 @@
-const getFunctionTemplate = ({ description, events, extension, language, route, schedule, trigger, }) => {
+const getFunctionTemplate = ({ description, events, extension, functionName, language, route, schedule, trigger, }) => {
+    if (trigger === 'workflow') {
+        return getWorkflowTemplate({
+            description,
+            functionName,
+            language,
+        });
+    }
     let typeAppend = ``;
     if (trigger === 'model') {
         const eventsList = events
@@ -37,4 +44,41 @@ export default async function (req${language === 'ts' ? ': SwellRequest' : ''})
 }
 `;
 };
+const getWorkflowTemplate = ({ description, functionName, language, }) => {
+    const className = toWorkflowClassName(functionName);
+    const reqParam = language === 'ts' ? 'req: SwellWorkflowRequest' : 'req';
+    const stepParam = language === 'ts' ? 'step: SwellWorkflowStep' : 'step';
+    return `export const config = {
+  kind: 'workflow',
+  description: '${description}'
+};
+
+export default class ${className} {
+  async run(${reqParam}, ${stepParam}) {
+    await step.do('load settings', async () => {
+      await req.swell.settings();
+    });
+
+    return {
+      data: req.data,
+    };
+  }
+}
+`;
+};
+const toWorkflowClassName = (functionName) => {
+    const baseName = functionName
+        .split(/[/\\]/)
+        .pop()
+        ?.replace(/\.[cm]?[jt]sx?$/i, '');
+    const className = (baseName || 'workflow')
+        .split(/[^\dA-Za-z]+/g)
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() || ''}${part.slice(1)}`)
+        .join('');
+    if (!className) {
+        return 'Workflow';
+    }
+    return /^[$A-Z_a-z]/.test(className) ? className : `Workflow${className}`;
+};
 export { getFunctionTemplate, };

package/dist/lib/function-source-analysis.d.ts

@@ -0,0 +1,16 @@
+export type FunctionSourceKind = 'function' | 'workflow' | 'unknown';
+export interface FunctionSourceAnalysis {
+    config?: Record<string, unknown>;
+    kind: FunctionSourceKind;
+    defaultExport?: {
+        name?: string;
+        reason?: string;
+        validWorkflowClass: boolean;
+    };
+    diagnostics: string[];
+}
+export declare function analyzeFunctionSource(filePath: string): Promise<FunctionSourceAnalysis>;
+export declare function analyzeFunctionSourceText(sourceText: string, filePath?: string): FunctionSourceAnalysis;
+export declare function getFunctionTriggers(config: Record<string, unknown>): string[];
+export declare function hasKindDiagnostic(analysis: FunctionSourceAnalysis): boolean;
+export declare function workflowStaticConfigError(): Error;