@stacksjs/actions 0.70.88 → 0.70.90

package/dist/dev/api.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/api.js

@@ -0,0 +1,94 @@
+import { existsSync } from "node:fs";
+import process from "node:process";
+import { parseOptions } from "@stacksjs/cli";
+import { config, overridesReady } from "@stacksjs/config";
+import { path } from "@stacksjs/path";
+import { route } from "@stacksjs/router";
+import { generateAutoImportFiles, injectGlobalAutoImports } from "@stacksjs/server";
+const _options = parseOptions();
+await overridesReady;
+const port = Number(process.env.PORT_API) || config.ports?.api || 3008, modelsIndex = path.storagePath("framework/auto-imports/models.ts");
+if (!existsSync(modelsIndex))
+  await generateAutoImportFiles();
+await injectGlobalAutoImports();
+try {
+  const typesenseDev = path.appPath("Lib/typesense-dev.ts");
+  if (existsSync(typesenseDev)) {
+    const mod = await import(typesenseDev);
+    if (typeof mod.ensureTypesenseRunning === "function")
+      await mod.ensureTypesenseRunning();
+  }
+} catch (err) {
+  const { log } = await import("@stacksjs/cli");
+  log.warn(`[api:dev] search engine bootstrap skipped: ${err.message}`);
+}
+try {
+  const listenerPath = path.appPath("Listener.ts");
+  if (existsSync(listenerPath)) {
+    const listener = await import(listenerPath);
+    if (typeof listener.handleEvents === "function")
+      await listener.handleEvents();
+  }
+} catch (err) {
+  const { log } = await import("@stacksjs/cli");
+  log.warn(`[api:dev] failed to bootstrap event listeners \u2014 dispatched events will be ignored: ${err.message}`);
+}
+try {
+  const { startModelMigrationWatcher } = await import("./migrate-watcher");
+  startModelMigrationWatcher();
+} catch (err) {
+  const { log } = await import("@stacksjs/cli");
+  log.debug(`[api:dev] auto-migrate watcher not started: ${err.message}`);
+}
+function resolveDefaultsCorsPath() {
+  const vendored = path.frameworkPath("defaults/app/Middleware/Cors.ts");
+  if (existsSync(vendored))
+    return vendored;
+  try {
+    return `${Bun.resolveSync("@stacksjs/defaults/package.json", process.cwd()).replace(/package\.json$/, "")}app/Middleware/Cors.ts`;
+  } catch {
+    return vendored;
+  }
+}
+const corsMod = await import(resolveDefaultsCorsPath()), corsMiddleware = corsMod.default;
+route.use(corsMiddleware.toRouterHandler());
+const SAFE_REQUEST_ID = /^[a-zA-Z0-9._-]{8,128}$/;
+route.use(async (request, next) => {
+  const inbound = request?.headers?.get?.("x-request-id") || request?.headers?.get?.("X-Request-ID") || "", id = typeof inbound === "string" && SAFE_REQUEST_ID.test(inbound) ? inbound : crypto.randomUUID();
+  request._requestId = id;
+  request._startNs = process.hrtime.bigint();
+  const response = await next();
+  if (response && response.status === 404 && (response.headers.get("content-type") || "").includes("json"))
+    try {
+      const body = await response.clone().json();
+      if (body && (body.message === "Not Found" || body.error === "Not Found")) {
+        const url = new URL(request.url), enriched = {
+          ...body,
+          path: url.pathname,
+          method: request.method,
+          request_id: id
+        }, headers = new Headers(response.headers);
+        headers.set("X-Request-ID", id);
+        return new Response(JSON.stringify(enriched), { status: 404, headers });
+      }
+    } catch {}
+  return response;
+});
+await route.importRoutes();
+try {
+  await route.serve({
+    port,
+    hostname: "127.0.0.1"
+  });
+  console.log(`
+  \u279C  API server ready: http://localhost:${port}
+`);
+} catch (err) {
+  if ((err?.code || err?.errno) === "EADDRINUSE" || String(err?.message || "").includes("EADDRINUSE")) {
+    console.error(`
+[dev/api] Port ${port} is already in use. Kill the other process and re-run \`./buddy dev\`, or set PORT_API to another port.
+`);
+    process.exit(1);
+  }
+  throw err;
+}

package/dist/dev/components.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dev/components.js

@@ -0,0 +1,7 @@
+import { parseOptions, runCommand } from "@stacksjs/cli";
+import { libsPath } from "@stacksjs/path";
+const options = parseOptions();
+await runCommand("bun run dev", {
+  ...options,
+  cwd: libsPath("components/vue")
+});

package/dist/dev/dashboard-globals.d.ts

@@ -0,0 +1,4 @@
+export declare function hoistDashboardGlobals(opts?: HoistOptions): Promise<void>;
+declare interface HoistOptions {
+  verbose?: boolean
+}

package/dist/dev/dashboard-globals.js

@@ -0,0 +1,89 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import { projectPath, storagePath } from "@stacksjs/path";
+const HELPER_DIRS = [
+  storagePath("framework/defaults/resources/functions/dashboard"),
+  projectPath("resources/functions"),
+  projectPath("app/Helpers")
+];
+export async function hoistDashboardGlobals(opts = {}) {
+  const g = globalThis, collisions = [];
+  let hoisted = 0;
+  for (const dir of HELPER_DIRS) {
+    if (!existsSync(dir))
+      continue;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry);
+      let s;
+      try {
+        s = statSync(full);
+      } catch {
+        continue;
+      }
+      if (s.isDirectory()) {
+        let subEntries;
+        try {
+          subEntries = readdirSync(full);
+        } catch {
+          continue;
+        }
+        for (const sub of subEntries) {
+          if (!isImportable(sub))
+            continue;
+          const subFull = join(full, sub), r = await hoistFile(subFull, g, opts.verbose);
+          hoisted += r.added;
+          collisions.push(...r.collisions);
+        }
+        continue;
+      }
+      if (!isImportable(entry))
+        continue;
+      const r = await hoistFile(full, g, opts.verbose);
+      hoisted += r.added;
+      collisions.push(...r.collisions);
+    }
+  }
+  if (opts.verbose)
+    process.stdout.write(`[dashboard] hoisted ${hoisted} helper globals` + (collisions.length > 0 ? ` (skipped ${collisions.length} collisions: ${collisions.slice(0, 5).join(", ")}\u2026)` : "") + `
+`);
+}
+function isImportable(name) {
+  if (!/\.(?:ts|tsx|js|mjs)$/.test(name))
+    return !1;
+  if (name.startsWith("_"))
+    return !1;
+  if (name.endsWith(".test.ts") || name.endsWith(".spec.ts"))
+    return !1;
+  if (name.endsWith(".d.ts"))
+    return !1;
+  return !0;
+}
+async function hoistFile(file, g, _verbose) {
+  let mod;
+  try {
+    mod = await import(file);
+  } catch {
+    return { added: 0, collisions: [] };
+  }
+  const collisions = [];
+  let added = 0;
+  for (const [name, value] of Object.entries(mod)) {
+    if (name === "default" || name.startsWith("_"))
+      continue;
+    if (typeof value === "function" || value && typeof value === "object") {
+      if (g[name] === void 0) {
+        g[name] = value;
+        added++;
+      } else if (g[name] !== value)
+        collisions.push(name);
+    }
+  }
+  return { added, collisions };
+}

package/dist/dev/dashboard-utils.d.ts

@@ -0,0 +1,150 @@
+import type { DashboardModelOptions } from '@stacksjs/types';
+/** Convert PascalCase model name to kebab-case ID */
+export declare function modelNameToId(name: string): string;
+/** Get the icon for a model name, falling back to the default */
+export declare function getModelIcon(name: string): string;
+/** Scan a directory for model files and add them to the models array */
+export declare function scanModelsDir(dir: string, seenNames: Set<string>, models: DiscoveredModel[], defaultCategory?: ModelCategory): Promise<void>;
+/** Discover models from both user and default directories */
+export declare function discoverModels(userModelsPath: string, defaultModelsPath: string): Promise<DiscoveredModel[]>;
+/** Build the manifest array for discovered models */
+export declare function buildManifest(models: DiscoveredModel[]): DiscoveredModelManifestRow[];
+/** Check if a port is available by attempting to listen on it */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/** Find an available port starting from the preferred port */
+export declare function findAvailablePort(preferred: number, maxAttempts?: number): Promise<number>;
+/** Wait for STX server to accept connections */
+export declare function waitForServer(port: number, maxWait?: number): Promise<boolean>;
+/** Build sidebar config for native sidebar navigation */
+export declare function buildSidebarConfig(baseRoute: string, discoveredModels: DiscoveredModel[], toggles?: DashboardSectionToggles): void;
+/**
+ * Build the URL the Craft window opens to. The `native-sidebar=1` query
+ * param signals the layout that Craft is rendering the sidebar natively,
+ * so the layout can suppress its own HTML sidebar and let the macOS
+ * NSOutlineView own that 240px column.
+ */
+export declare function buildDashboardUrl(port: number): string;
+/**
+ * Model name to icon mapping (SF Symbols)
+ * @defaultValue
+ * ```ts
+ * {
+ *   user: 'person.fill',
+ *   team: 'person.2.fill',
+ *   subscriber: 'envelope.open.fill',
+ *   subscriberemail: 'envelope.fill',
+ *   post: 'doc.text.fill',
+ *   page: 'doc.fill',
+ *   product: 'cube.box.fill',
+ *   productvariant: 'cube.fill',
+ *   productunit: 'scalemass.fill',
+ *   order: 'list.clipboard.fill',
+ *   orderitem: 'list.bullet.clipboard.fill',
+ *   customer: 'person.crop.circle.fill',
+ *   payment: 'creditcard.fill',
+ *   paymentmethod: 'creditcard.and.123',
+ *   paymentproduct: 'creditcard.fill',
+ *   paymenttransaction: 'creditcard.fill',
+ *   category: 'tag.fill',
+ *   tag: 'tag',
+ *   comment: 'bubble.left.fill',
+ *   author: 'person.text.rectangle.fill',
+ *   notification: 'bell.fill',
+ *   job: 'briefcase.fill',
+ *   log: 'list.bullet.rectangle.portrait.fill',
+ *   campaign: 'megaphone.fill',
+ *   review: 'star.fill',
+ *   coupon: 'ticket.fill',
+ *   giftcard: 'giftcard.fill',
+ *   cart: 'cart.fill',
+ *   cartitem: 'cart.badge.plus',
+ *   taxrate: 'percent',
+ *   transaction: 'arrow.left.arrow.right.circle.fill',
+ *   subscription: 'repeat.circle.fill',
+ *   emaillist: 'envelope.badge.person.crop',
+ *   socialpost: 'bubble.left.and.bubble.right.fill',
+ *   manufacturer: 'building.2.fill',
+ *   shippingmethod: 'shippingbox.fill',
+ *   shippingzone: 'map.fill',
+ *   shippingrate: 'dollarsign.circle.fill',
+ *   deliveryroute: 'map.fill',
+ *   driver: 'car.fill',
+ *   digitaldelivery: 'arrow.down.doc.fill',
+ *   licensekey: 'key.fill',
+ *   loyaltypoint: 'star.circle.fill',
+ *   loyaltyreward: 'gift.fill',
+ *   printdevice: 'printer.fill',
+ *   receipt: 'doc.text.fill',
+ *   waitlistproduct: 'clock.fill',
+ *   waitlistrestaurant: 'clock.badge.checkmark.fill',
+ *   websocket: 'antenna.radiowaves.left.and.right',
+ *   default: 'tablecells.fill'
+ * }
+ * ```
+ */
+export declare const iconMap: Record<string, string>;
+// Models excluded from sidebar (already have dedicated pages)
+export declare const excludeModels: Set<any>;
+// Models that have dedicated dashboard pages
+export declare const dedicatedPages: Set<any>;
+export declare interface DiscoveredModel {
+  name: string
+  icon: string
+  id: string
+  category?: ModelCategory
+  dashboard?: DashboardModelOptions
+}
+/**
+ * Manifest row written to `defaults/views/dashboard/.discovered-models.json`
+ * for the web-side sidebar to consume. Includes the per-model `dashboard`
+ * config (stacksjs/stacks#1843) so both sidebar builders (the native one
+ * here and the HTML one in `defaults/resources/functions/dashboard/sidebar.ts`)
+ * see the same data.
+ */
+export declare interface DiscoveredModelManifestRow {
+  id: string
+  name: string
+  icon: string
+  hasDedicatedPage: boolean
+  category: ModelCategory
+  dashboard?: DashboardModelOptions
+}
+/**
+ * Per-section toggles. Read from the project's `config/dashboard.ts` (when
+ * present) and passed through buildSidebarConfig / buildSidebarNavHtml so the
+ * commerce / content / marketing sections collapse out of the sidebar entirely
+ * for projects that don't ship those features. Anything not specified is on.
+ *
+ * `data` is a per-row toggle map (instead of a single boolean) because the
+ * Data section is always relevant — projects just want to hide individual
+ * basic rows like Subscribers when they're not running a newsletter, while
+ * still seeing their userland models.
+ */
+export declare interface DashboardSectionToggles {
+  commerce?: boolean
+  content?: boolean
+  marketing?: boolean
+  analytics?: boolean
+  management?: boolean
+  utilities?: boolean
+  library?: boolean
+  ci?: boolean
+  data?: {
+    dashboard?: boolean
+    activity?: boolean
+    users?: boolean
+    teams?: boolean
+    subscribers?: boolean
+    allModels?: boolean
+  }
+}
+/**
+ * Sidebar category each discovered model gets surfaced under.
+ * - `userland`: model in the project's `app/Models/` (always shown in Data)
+ * - `data`: framework root-level model that belongs in Data
+ * - `commerce`: model in framework `commerce/` subdir or commerce-coded root model
+ * - `content`: model in framework `Content/` subdir or content-coded root model
+ * - `marketing`: outreach / subscriber-list models grouped under Marketing
+ * - `system`: framework-internal models (jobs, deployments, requests…) → App
+ */
+export type ModelCategory = 'userland' | 'data' | 'commerce' | 'content' | 'marketing' | 'system';