@fold-run/github-action 1.0.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@fold-run/github-action",
+  "version": "1.0.0",
+  "description": "GitHub Action for deploying functions to Fold",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "esbuild src/main.ts --bundle --platform=node --target=node20 --outfile=dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@actions/core": "^1.11.1",
+    "@actions/exec": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}

package/src/main.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// ── Hoisted mocks (vi.mock factories run before module imports) ────────────
+
+const mockCore = vi.hoisted(() => ({
+  getInput: vi.fn(),
+  setOutput: vi.fn(),
+  setFailed: vi.fn(),
+  info: vi.fn(),
+  summary: {
+    addHeading: vi.fn().mockReturnThis(),
+    addTable: vi.fn().mockReturnThis(),
+    write: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+const mockExec = vi.hoisted(() => ({
+  exec: vi.fn().mockResolvedValue(0),
+}));
+
+const mockFs = vi.hoisted(() => ({
+  readFileSync: vi.fn(),
+  unlinkSync: vi.fn(),
+}));
+
+vi.mock('@actions/core', () => mockCore);
+vi.mock('@actions/exec', () => mockExec);
+vi.mock('node:fs', () => mockFs);
+
+// ── Import after mocks ─────────────────────────────────────────────────────
+
+import { bundleFile, run } from './main';
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function setupInputs(overrides: Record<string, string> = {}) {
+  const defaults: Record<string, string> = {
+    'fold-token': 'fld_test',
+    'tenant-id': 'my-tenant',
+    'function-name': 'my-fn',
+    file: 'worker.js',
+    'working-directory': '.',
+    'api-url': 'https://api.fold.run',
+  };
+  mockCore.getInput.mockImplementation((name: string) => overrides[name] ?? defaults[name] ?? '');
+}
+
+function makeDeployResponse(overrides: Partial<{ id: string; name: string; version: number; status: string }> = {}) {
+  return { id: 'fn-abc', name: 'my-fn', version: 1, status: 'active', ...overrides };
+}
+
+// ── bundleFile ─────────────────────────────────────────────────────────────
+
+describe('bundleFile', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('reads JS files directly without bundling', async () => {
+    mockFs.readFileSync.mockReturnValue('export default {}');
+    const result = await bundleFile('worker.js', '/tmp/work');
+    expect(mockFs.readFileSync).toHaveBeenCalledWith(expect.stringContaining('worker.js'), 'utf-8');
+    expect(mockExec.exec).not.toHaveBeenCalled();
+    expect(result).toBe('export default {}');
+  });
+
+  it('bundles TypeScript files using esbuild via exec', async () => {
+    mockExec.exec.mockResolvedValue(0);
+    mockFs.readFileSync.mockReturnValue('bundled code');
+    await bundleFile('worker.ts', '/tmp/work');
+    expect(mockExec.exec).toHaveBeenCalledWith(
+      'npx',
+      expect.arrayContaining(['--yes', 'esbuild@0.25', expect.stringContaining('worker.ts')]),
+      expect.objectContaining({ cwd: '/tmp/work' }),
+    );
+  });
+
+  it('bundles .tsx files the same as .ts', async () => {
+    mockExec.exec.mockResolvedValue(0);
+    mockFs.readFileSync.mockReturnValue('bundled');
+    await bundleFile('component.tsx', '/tmp');
+    expect(mockExec.exec).toHaveBeenCalled();
+  });
+
+  it('throws when esbuild exits non-zero', async () => {
+    mockExec.exec.mockResolvedValue(1);
+    await expect(bundleFile('worker.ts', '/tmp')).rejects.toThrow('esbuild exited with code 1');
+  });
+
+  it('throws when exec itself throws (esbuild not available)', async () => {
+    mockExec.exec.mockRejectedValue(new Error('command not found'));
+    await expect(bundleFile('worker.ts', '/tmp')).rejects.toThrow('esbuild not available');
+  });
+});
+
+// ── run ────────────────────────────────────────────────────────────────────
+
+describe('run', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.stubGlobal('fetch', vi.fn());
+    setupInputs();
+    mockFs.readFileSync.mockReturnValue('export default {}');
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('deploys successfully and sets outputs', async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(makeDeployResponse()), { status: 200 }));
+
+    await run();
+
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.fold.run/deploy/my-tenant',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({ Authorization: 'Bearer fld_test' }),
+      }),
+    );
+    expect(mockCore.setOutput).toHaveBeenCalledWith('function-id', 'fn-abc');
+    expect(mockCore.setOutput).toHaveBeenCalledWith('version', '1');
+    expect(mockCore.setOutput).toHaveBeenCalledWith('url', 'https://my-tenant.fold.run/my-fn');
+    expect(mockCore.setFailed).not.toHaveBeenCalled();
+  });
+
+  it('constructs the correct tenant subdomain URL', async () => {
+    setupInputs({ 'tenant-id': 'acme', 'function-name': 'weather' });
+    vi.mocked(fetch).mockResolvedValue(
+      new Response(JSON.stringify(makeDeployResponse({ name: 'weather' })), { status: 200 }),
+    );
+
+    await run();
+
+    expect(mockCore.setOutput).toHaveBeenCalledWith('url', 'https://acme.fold.run/weather');
+  });
+
+  it('sends correct deploy body without runtime field', async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(makeDeployResponse()), { status: 200 }));
+
+    await run();
+
+    const [, init] = vi.mocked(fetch).mock.calls[0];
+    const body = JSON.parse((init as RequestInit).body as string);
+    expect(body).toEqual({ name: 'my-fn', code: 'export default {}' });
+    expect(body.runtime).toBeUndefined();
+  });
+
+  it('calls setFailed when API returns non-ok', async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      new Response(JSON.stringify({ error: 'Function limit reached' }), { status: 422 }),
+    );
+
+    await run();
+
+    expect(mockCore.setFailed).toHaveBeenCalledWith('Function limit reached');
+    expect(mockCore.setOutput).not.toHaveBeenCalled();
+  });
+
+  it('calls setFailed on network error', async () => {
+    vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
+
+    await run();
+
+    expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining('Network error'));
+  });
+
+  it('calls setFailed when bundling fails', async () => {
+    setupInputs({ file: 'worker.ts' });
+    mockExec.exec.mockResolvedValue(1);
+
+    await run();
+
+    expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining('Failed to bundle'));
+  });
+
+  it('uses custom api-url', async () => {
+    setupInputs({ 'api-url': 'http://localhost:8787' });
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(makeDeployResponse()), { status: 200 }));
+
+    await run();
+
+    expect(fetch).toHaveBeenCalledWith('http://localhost:8787/deploy/my-tenant', expect.anything());
+  });
+});

package/src/main.ts

@@ -0,0 +1,125 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as core from '@actions/core';
+import * as exec from '@actions/exec';
+
+interface DeployResponse {
+  id: string;
+  name: string;
+  version: number;
+  status: string;
+}
+
+export async function bundleFile(filePath: string, workingDir: string): Promise<string> {
+  const absPath = path.resolve(workingDir, filePath);
+  const ext = path.extname(absPath);
+  const isTypeScript = ext === '.ts' || ext === '.tsx';
+
+  if (!isTypeScript) {
+    // Plain JS — read directly
+    return fs.readFileSync(absPath, 'utf-8');
+  }
+
+  // Bundle TypeScript with esbuild
+  const outFile = path.join(os.tmpdir(), `fold-action-bundle-${Date.now()}.js`);
+  const args = [absPath, '--bundle', '--platform=browser', '--format=esm', '--target=es2022', `--outfile=${outFile}`];
+
+  core.info(`Bundling ${filePath} with esbuild...`);
+  let exitCode = 0;
+  try {
+    exitCode = await exec.exec('npx', ['--yes', 'esbuild@0.25', ...args], {
+      cwd: workingDir,
+      ignoreReturnCode: true,
+    });
+  } catch (err) {
+    throw new Error(`esbuild not available: ${err}`);
+  }
+
+  if (exitCode !== 0) {
+    throw new Error(`esbuild exited with code ${exitCode}`);
+  }
+
+  const bundle = fs.readFileSync(outFile, 'utf-8');
+  fs.unlinkSync(outFile);
+  return bundle;
+}
+
+export async function run(): Promise<void> {
+  const token = core.getInput('fold-token', { required: true });
+  const tenantId = core.getInput('tenant-id', { required: true });
+  const functionName = core.getInput('function-name', { required: true });
+  const file = core.getInput('file', { required: true });
+  const workingDir = core.getInput('working-directory') || '.';
+  const apiUrl = core.getInput('api-url') || 'https://api.fold.run';
+
+  const absWorkingDir = path.resolve(process.cwd(), workingDir);
+
+  // Bundle / read the function source
+  let code: string;
+  try {
+    code = await bundleFile(file, absWorkingDir);
+  } catch (err) {
+    core.setFailed(`Failed to bundle function: ${err}`);
+    return;
+  }
+
+  // Deploy via Fold API
+  core.info(`Deploying function "${functionName}" to ${apiUrl}...`);
+
+  let res: Response;
+  try {
+    res = await fetch(`${apiUrl}/deploy/${tenantId}`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ name: functionName, code }),
+    });
+  } catch (err) {
+    core.setFailed(`Network error: ${err}`);
+    return;
+  }
+
+  if (!res.ok) {
+    let message = `Deploy failed with HTTP ${res.status}`;
+    try {
+      const body = (await res.json()) as { error?: string; message?: string };
+      message = body.error ?? body.message ?? message;
+    } catch {
+      // ignore parse error
+    }
+    core.setFailed(message);
+    return;
+  }
+
+  const fn = (await res.json()) as DeployResponse;
+
+  const functionUrl = `https://${tenantId}.fold.run/${functionName}`;
+  core.setOutput('function-id', fn.id);
+  core.setOutput('version', String(fn.version ?? '1'));
+  core.setOutput('url', functionUrl);
+
+  // Job summary
+  await core.summary
+    .addHeading('Fold Deploy')
+    .addTable([
+      [
+        { data: 'Field', header: true },
+        { data: 'Value', header: true },
+      ],
+      ['Function', fn.name],
+      ['ID', fn.id],
+      ['Version', String(fn.version ?? '1')],
+      ['URL', functionUrl],
+      ['Status', fn.status ?? 'active'],
+    ])
+    .write();
+
+  core.info(`Deployed: ${functionUrl}`);
+}
+
+run().catch((err) => {
+  core.setFailed(String(err));
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+});