rastack 0.0.63 → 0.0.69

package/src/deploy/io.ts

@@ -6,11 +6,20 @@
 
 import { execFileSync, execSync } from "child_process";
 import * as fs from "fs";
+import * as https from "https";
 import * as os from "os";
 import * as path from "path";
 import * as readline from "readline";
 import { CONFIG_PATH } from "./workflows";
-import { DeployConfig, PartialDeployConfig, normalizeConfig } from "./config";
+import {
+  BOOTSTRAP_ARTIFACTS_OUTPUT,
+  BOOTSTRAP_TEMPLATES_OUTPUT,
+  DeployConfig,
+  PartialDeployConfig,
+  bootstrapStackArgs,
+  bootstrapStackName,
+  normalizeConfig,
+} from "./config";
 import { zipStore } from "./zip";
 
 /** Absolute path to the deploy config for a project root. */
@@ -50,6 +59,65 @@ export function resolveDeployAsset(
   return null;
 }
 
+/**
+ * Base URL the framework's CloudFormation templates are published at. The same
+ * site that hosts the installer (`reactapistack.com/setup.sh`) serves the base
+ * templates, so a CLI whose bundled copy is missing (a partial install, or a
+ * globally-linked dev build) can still fetch them.
+ */
+export const TEMPLATE_BASE_URL = "https://reactapistack.com/cloudformation";
+
+/**
+ * Download a published CloudFormation template to a temp file, returning its
+ * path — or null on any failure (offline, 404, write error). Used as the
+ * fallback when the template is not bundled with the install.
+ */
+export function downloadTemplate(
+  name: string,
+  base = TEMPLATE_BASE_URL,
+): Promise<string | null> {
+  const url = `${base}/${name}`;
+  return new Promise((resolve) => {
+    https
+      .get(url, (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        const chunks: Buffer[] = [];
+        res.on("data", (c: Buffer) => chunks.push(c));
+        res.on("end", () => {
+          try {
+            const dest = path.join(
+              os.tmpdir(),
+              `rastack-${path.basename(name)}`,
+            );
+            fs.writeFileSync(dest, Buffer.concat(chunks));
+            resolve(dest);
+          } catch {
+            resolve(null);
+          }
+        });
+      })
+      .on("error", () => resolve(null));
+  });
+}
+
+/**
+ * Resolve a CloudFormation template to a local file path for `aws cloudformation
+ * deploy` (which accepts only `--template-file`). Prefers the copy bundled with
+ * the `rastack` install; when that is missing, downloads it from the React API
+ * Stack website. Returns null only when the template is neither bundled nor
+ * fetchable.
+ */
+export async function resolveTemplateFile(
+  name: string,
+  cwd = process.cwd(),
+): Promise<string | null> {
+  return resolveDeployAsset(name, cwd) ?? (await downloadTemplate(name));
+}
+
 /** Read + normalize the deploy config, or null when it does not exist yet. */
 export function loadConfig(cwd = process.cwd()): DeployConfig | null {
   const file = configPath(cwd);
@@ -121,6 +189,26 @@ export function awsAvailable(): boolean {
   return awsCapture(["--version"]) !== null;
 }
 
+/**
+ * The AWS account id the CLI's active credentials resolve to, or null when the
+ * CLI has no usable credentials (not logged in, an expired SSO session, or no
+ * configured profile). `init`/`bootstrap` call this to fail fast with an
+ * actionable "log in" message before attempting a stack deploy, instead of
+ * letting the first `cloudformation deploy` fail with a cryptic AWS error.
+ */
+export function awsIdentity(region?: string): string | null {
+  const args = [
+    "sts",
+    "get-caller-identity",
+    "--query",
+    "Account",
+    "--output",
+    "text",
+  ];
+  if (region) args.push("--region", region);
+  return awsCapture(args);
+}
+
 /**
  * A single Output value of a CloudFormation stack, or null when the stack does
  * not exist or the key is unset. `describe-stacks` prints `None` for a missing
@@ -176,6 +264,79 @@ export function uploadPlaceholder(
   return true;
 }
 
+/**
+ * Deploy the tier-0 bootstrap stack, retrying once against an account that
+ * already has a GitHub OIDC provider — AWS allows only one provider per URL, so
+ * a second create is rejected and the retry tells the template to reuse the
+ * existing one. Throws on failure (after the retry). Shared by `rastack init`
+ * and `rastack bootstrap` so both stand the stack up identically.
+ */
+export function deployBootstrap(
+  cfg: DeployConfig,
+  reuseOidc: boolean,
+  template: string,
+): void {
+  try {
+    awsRun(bootstrapStackArgs(cfg, reuseOidc, template));
+  } catch (err) {
+    if (reuseOidc) throw err;
+    console.log(
+      "  • retrying bootstrap, reusing the account's existing GitHub OIDC provider",
+    );
+    awsRun(bootstrapStackArgs(cfg, true, template));
+  }
+}
+
+/**
+ * Ensure the tier-0 bootstrap stack exists for this account+region, **creating
+ * it when missing**, and return its artifacts/templates buckets. This is why
+ * `rastack init` is a single command that stands up *everything* — the
+ * account-level bootstrap stack and the per-app backend — with no separate
+ * `rastack bootstrap` step. Idempotent: an existing stack is reconciled in
+ * place. Throws with an actionable message when the template cannot be resolved,
+ * the deploy fails, or the buckets can't be read back.
+ */
+export async function ensureBootstrapStack(
+  cfg: DeployConfig,
+  reuseOidc = false,
+): Promise<{ artifactsBucket: string; templatesBucket: string | null }> {
+  const stack = bootstrapStackName(cfg);
+  const existing = stackOutput(stack, BOOTSTRAP_ARTIFACTS_OUTPUT, cfg.region);
+  if (existing) {
+    console.log(`  ✓ bootstrap stack ${stack} already exists — reconciling`);
+  } else {
+    console.log(
+      `\n▸ Creating the tier-0 bootstrap stack ${stack} (@ ${cfg.region})`,
+    );
+  }
+
+  const template = await resolveTemplateFile("bootstrap.yaml");
+  if (!template) {
+    throw new Error(
+      "bootstrap.yaml template not found in the rastack package and could not be\n" +
+        "    downloaded from reactapistack.com. Reinstall rastack (`npm i -g rastack`).",
+    );
+  }
+  deployBootstrap(cfg, reuseOidc, template);
+
+  const artifactsBucket = stackOutput(
+    stack,
+    BOOTSTRAP_ARTIFACTS_OUTPUT,
+    cfg.region,
+  );
+  const templatesBucket = stackOutput(
+    stack,
+    BOOTSTRAP_TEMPLATES_OUTPUT,
+    cfg.region,
+  );
+  if (!artifactsBucket) {
+    throw new Error(
+      `bootstrap stack ${stack} deployed but its ArtifactsBucket output could not be read.`,
+    );
+  }
+  return { artifactsBucket, templatesBucket };
+}
+
 // ── GitHub CLI boundary ──────────────────────────────────────────────────────
 // After the stack is up `init` wires the two repo Variables CI reads
 // (AWS_DEPLOY_ROLE_ARN / AWS_REGION) through the developer's own `gh` — already

package/src/deploy/workflows.ts

@@ -124,7 +124,7 @@ jobs:
       - name: Cache cargo
         uses: Swatinem/rust-cache@v2
         with:
-          workspaces: rust
+          workspaces: engine
       # cargo-lambda cross-builds the custom-runtime binary; it auto-installs
       # zig (via pip) for the cross-compile when needed.
       - name: Install cargo-lambda

package/src/dev/harness.ts

@@ -1,20 +1,18 @@
 /**
- * Pure core of `rastack dev` — the local, always-WASM development server.
+ * Pure core of `rastack dev` — local development against the native Rust server.
  *
- * `rastack dev` runs **your app** in the browser over the WebAssembly engine
- * (the same app-generic `rastack-api-core` the Lambda runs, fed the app's
- * compiled manifest). No native server, no cargo: a dependency-free static
- * server hands the browser the prebuilt wasm engine, the compiled schema, the
- * committed Iceberg warehouse, and the developer's own app. It does **not**
- * serve the admin console — that is a separate command, `rastack admin`.
+ * `rastack dev` serves **your app** from Node and proxies `/api` to a native
+ * `rastack-server` process (the same `rastack-api-core` Lambda runs). The
+ * browser renders the UI. It does not execute the engine. `rastack admin` is
+ * the separate command that starts `rastack-server admin`.
  *
  * When the project has no app to serve, `dev` shows a Django-style welcome
  * page (`renderWelcome`) so a fresh scaffold still boots to something friendly.
  *
- * Everything decidable without IO lives here (arg parsing, MIME types, locating
- * the wasm bundle, resolving the app root, the HTML pages) so it is unit-tested
- * without a socket or a filesystem; `rastack-dev.ts` is the thin IO wrapper that
- * compiles, resolves the engine and the app, and serves.
+ * Everything decidable without IO lives here (arg parsing, MIME types, where
+ * the native binary is looked up, resolving the app root, the HTML pages) so
+ * it is unit-tested without a socket or a filesystem; `rastack-dev.ts` is the
+ * thin IO wrapper that compiles, starts the server, and serves.
  */
 
 import * as path from "path";
@@ -24,7 +22,7 @@ export interface DevArgs {
   resourcesDir: string;
   /** Where `rastack compile` writes schema.rastack.json + openapi.json. */
   outDir: string;
-  /** The committed Iceberg warehouse served to seed the browser engine. */
+  /** The on-disk Iceberg warehouse the native server opens. */
   warehouseDir: string;
   /**
    * Explicit app root to serve at `/` (its `index.html`). Empty when unset —
@@ -139,7 +137,6 @@ const MIME: Record<string, string> = {
   ".mjs": "text/javascript; charset=utf-8",
   ".css": "text/css; charset=utf-8",
   ".json": "application/json; charset=utf-8",
-  // Critical: `WebAssembly.instantiateStreaming` requires this exact type.
   ".wasm": "application/wasm",
   ".text": "text/plain; charset=utf-8",
   ".parquet": "application/octet-stream",
@@ -152,32 +149,22 @@ export function contentType(filePath: string): string {
 }
 
 /**
- * Ordered directories to look for the prebuilt wasm bundle (`rastack_wasm.js` +
- * `rastack_wasm_bg.wasm`). The bundle is shipped inside the package
- * (`dist/wasm/`, copied at build), so `rastack dev` works from any repo with no
- * cargo; the repo-local `wasm/` (from a source build) and a sibling of the
- * running module are fallbacks for development. `dirnameDir` is the directory of
- * the compiled `rastack-dev.js` (`dist/`), so `../wasm` and `./wasm` cover both
- * `dist/rastack-dev.js` → `dist/wasm` and `dist/dev/…` layouts.
+ * Ordered paths for the native `rastack-server` binary inside a workspace
+ * checkout. Release wins over debug. `RASTACK_SERVER` and `PATH` are checked
+ * by the IO wrapper, not here.
  */
-export function wasmBundleCandidates(
-  dirnameDir: string,
-  cwd = process.cwd(),
-): string[] {
+export function serverBinaryCandidates(cwd: string): string[] {
   return [
-    path.join(dirnameDir, "wasm"),
-    path.join(dirnameDir, "..", "wasm"),
-    path.join(cwd, "wasm"),
+    path.join(cwd, "engine", "target", "release", "rastack-server"),
+    path.join(cwd, "engine", "target", "debug", "rastack-server"),
   ];
 }
 
-/** The name of the file that marks a directory as a usable wasm bundle. */
-export const WASM_ENTRY = "rastack_wasm.js";
-
 /**
  * The HTML shell served at `/` by **`rastack admin`**. It loads the bundled
- * React admin (`/dev/admin.js`), which fetches the schema/openapi, boots the
- * wasm engine, seeds it from `/data/warehouse/`, and renders the admin console.
+ * React admin (`/dev/admin.js`). `rastack admin` itself does not serve this
+ * page: the native `rastack-server admin` process serves `/admin/` and the
+ * bundle talks to that process over HTTP.
  * Deliberately tiny — all logic lives in the bundle — mirroring the
  * `rastack design` studio. `rastack dev` does **not** use this: it serves the
  * developer's own app (or the welcome page below).
@@ -223,9 +210,8 @@ export function renderShell(title = "React API Stack — admin"): string {
 /**
  * The Django-style welcome page `rastack dev` serves at `/` when the project
  * has **no app** to serve (no `index.html` in any `appRootCandidates` dir).
- * It confirms the dev server is up, points at the live backend endpoints the
- * WASM engine exposes, and tells you how to add an app or open the admin — the
- * "It worked!" moment of `django-admin runserver`, on brand for the stack.
+ * It confirms the dev server is up, points at the native API proxied at
+ * `/api`, and tells you how to add an app or open the admin.
  */
 export function renderWelcome(title = "React API Stack — dev"): string {
   return `<!doctype html>
@@ -272,20 +258,21 @@ export function renderWelcome(title = "React API Stack — dev"): string {
   <div class="rocket">🚀</div>
   <h1>The dev server is running.</h1>
   <p class="lead">
-    Congratulations — <strong>rastack dev</strong> is up and your API is running
-    in the browser over WebAssembly. You're seeing this page because there's no
-    app to serve yet.
+    Congratulations — <strong>rastack dev</strong> is up. The API is a native
+    Rust process (<code>rastack-server</code>) on this machine. This page is
+    only the UI. You're seeing it because there's no app to serve yet.
   </p>
   <ul>
     <li>Add an <code>index.html</code> (in <code>public/</code>, <code>www/</code>,
       <code>app/</code>, or the project root) and reload — <code>dev</code> will serve it.
       Point it at a different folder with <code>rastack dev --app &lt;dir&gt;</code>.</li>
-    <li>Wire your app to the local engine with
-      <code>&lt;RAStackProvider mode="local"&gt;</code>.</li>
-    <li>Live backend endpoints:
+    <li>Wire your app with
+      <code>&lt;RAStackProvider mode="local"&gt;</code>. Requests go to
+      <code>/api</code> on this origin, which is proxied to the native server.</li>
+    <li>Live files:
       <a href="/schema.rastack.json">/schema.rastack.json</a>,
-      <a href="/openapi.json">/openapi.json</a>,
-      <code>/data/warehouse/…</code>, <code>/wasm/…</code>.</li>
+      <a href="/openapi.json">/openapi.json</a>.
+      The warehouse stays on disk; the browser does not load it.</li>
     <li>Want the database console instead? Run <code>rastack admin</code>.</li>
   </ul>
   <div class="foot">React API Stack — a full-stack framework on object storage.</div>

package/src/dev/native-server.ts

@@ -0,0 +1,164 @@
+/**
+ * Start the native `rastack-server` binary — the same `rastack-api-core`
+ * process Lambda runs. The browser never executes this binary. `rastack dev`
+ * proxies `/api` to it; `rastack admin` lets the binary serve `/admin` itself.
+ */
+
+import { spawn, spawnSync, type ChildProcess } from "child_process";
+import * as fs from "fs";
+import * as net from "net";
+import * as path from "path";
+import { serverBinaryCandidates } from "./harness";
+
+export interface NativeServerOpts {
+  /** Absolute path to the `rastack-server` binary. */
+  bin: string;
+  /** `serve` is the API. `admin` mounts the React console at `/admin`. */
+  command: "serve" | "admin";
+  manifest: string;
+  warehouse: string;
+  /** `host:port` the binary binds. */
+  addr: string;
+  /** Directory that contains `admin.js` (`RASTACK_ADMIN_ASSETS`). */
+  adminAssets?: string;
+}
+
+const MISSING = `
+  ✗ No native rastack-server binary.
+    The API does not run in the browser. rastack dev and rastack admin start
+    the native Rust server (rastack-api-core) and the page talks to it over HTTP.
+    Build it from this repo:
+
+      cargo build -p rastack-server --manifest-path engine/Cargo.toml
+
+    Or set RASTACK_SERVER to the binary. There is no in-browser engine.
+`;
+
+/**
+ * `rastack-server` on PATH. Walks the directories ourselves so the lookup
+ * never goes through a shell (`command -v` with `shell: true`).
+ */
+function serverOnPath(): string | null {
+  const entries = (process.env.PATH ?? "").split(path.delimiter);
+  for (const dir of entries) {
+    if (!dir) continue;
+    const candidate = path.join(dir, "rastack-server");
+    try {
+      if (fs.existsSync(candidate)) return candidate;
+    } catch {
+      // An unreadable PATH entry is not a candidate.
+    }
+  }
+  return null;
+}
+
+/** `RASTACK_SERVER`, a workspace target dir, or `rastack-server` on PATH. */
+export function resolveServerBinary(cwd: string): string | null {
+  const fromEnv = process.env.RASTACK_SERVER;
+  if (fromEnv && fs.existsSync(fromEnv)) return fromEnv;
+  for (const candidate of serverBinaryCandidates(cwd)) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return serverOnPath();
+}
+
+function cargoAvailable(): boolean {
+  try {
+    return spawnSync("cargo", ["--version"], { stdio: "ignore" }).status === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Locate the native binary, building it with cargo when this repo's workspace
+ * is present and the binary is not. Throws when nothing native can be started.
+ */
+export function ensureServerBinary(cwd: string): string {
+  const ready = resolveServerBinary(cwd);
+  if (ready) return ready;
+  const manifest = path.join(cwd, "engine", "Cargo.toml");
+  if (fs.existsSync(manifest) && cargoAvailable()) {
+    console.log(
+      "\n▸ Building native rastack-server (cargo build -p rastack-server)…\n",
+    );
+    const built = spawnSync(
+      "cargo",
+      ["build", "-p", "rastack-server", "--manifest-path", manifest],
+      { stdio: "inherit" },
+    );
+    if (built.status === 0) {
+      const after = resolveServerBinary(cwd);
+      if (after) return after;
+    }
+  }
+  throw new Error(MISSING.trim());
+}
+
+/** Spawn `rastack-server serve|admin`. Stdio is inherited. */
+export function startNativeServer(opts: NativeServerOpts): ChildProcess {
+  const env: NodeJS.ProcessEnv = { ...process.env };
+  if (opts.adminAssets) env.RASTACK_ADMIN_ASSETS = opts.adminAssets;
+  // `bin` is resolveServerBinary's result: RASTACK_SERVER (a file that exists),
+  // a workspace target path, or a PATH entry named rastack-server. It is not
+  // request input. The command cannot be a string literal because the path
+  // depends on which of those three resolved. The nosemgrep comment has to sit
+  // on the line directly above the tainted argument — that is the line Semgrep
+  // reports, not the `spawn(` line.
+  const bin = opts.bin;
+  return spawn(
+    // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+    bin,
+    [
+      opts.command,
+      "--manifest",
+      opts.manifest,
+      "--warehouse",
+      opts.warehouse,
+      "--addr",
+      opts.addr,
+      "--insecure-dev-auth",
+    ],
+    { stdio: "inherit", env },
+  );
+}
+
+/** Resolve once the process accepts TCP, or reject if it exits or times out. */
+export function waitForTcp(
+  port: number,
+  child: ChildProcess,
+  timeoutMs = 30_000,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    let settled = false;
+    const finish = (err?: Error) => {
+      if (settled) return;
+      settled = true;
+      if (err) reject(err);
+      else resolve();
+    };
+    child.once("exit", (code) =>
+      finish(
+        new Error(
+          `rastack-server exited (${code ?? "?"}) before it accepted connections`,
+        ),
+      ),
+    );
+    const tick = () => {
+      if (settled) return;
+      if (Date.now() > deadline) {
+        finish(
+          new Error(`rastack-server did not listen on 127.0.0.1:${port}`),
+        );
+        return;
+      }
+      const socket = net.connect(port, "127.0.0.1", () => {
+        socket.end();
+        finish();
+      });
+      socket.on("error", () => setTimeout(tick, 100));
+    };
+    tick();
+  });
+}

package/src/external/envelope.ts

@@ -1,7 +1,7 @@
 /**
  * Normalise an upstream response into rastack's REST contract — the DRF-shaped
  * list envelope and bare detail object the typed hooks and `<DataTable>` expect,
- * identical to what the Rust API and the WASM/local engine emit.
+ * identical to what the native Rust API emits.
  *
  * External APIs rarely page the way rastack does (GitHub uses `per_page` + Link
  * headers; a GraphQL list just returns an array), so the envelope is synthesised

package/src/external/service.ts

@@ -1,8 +1,8 @@
 /**
  * The mini local proxy service — the "lambda you run while iterating".
  *
- * `rastack dev` already serves the app + admin over WASM for the stack's *own*
- * resources. This adds the other half for **external** resources: a request
+ * `rastack dev` proxies the stack's own resources to the native
+ * `rastack-server`. This adds the other half for **external** resources: a request
  * handler it mounts under `/api/`, so `useData("github.repo")` works locally,
  * cached, before any real Lambda is deployed. It is a thin adapter over the pure
  * {@link handleExternalRequest} core — parse the path, resolve dev auth from env

package/src/external/types.ts

@@ -2,7 +2,7 @@
  * External-API bindings — how a rastack `app.model` is served from an upstream
  * REST or GraphQL API.
  *
- * The stack's own resources are served by the Rust API / WASM engine over the
+ * The stack's own resources are served by the native Rust API over the
  * `/api/{app}/v1/{model}/` contract. An **external** resource (a GitHub repo, an
  * Expo project, an AWS stack) is served by the proxy instead: it speaks the same
  * contract to the client, and translates each request into an upstream call,