create-oke 0.1.4

package/templates/provisions/src/flows/orders/index.ts

@@ -0,0 +1,70 @@
+import { on, flow, gate, http } from "okengine";
+import { eq } from "drizzle-orm";
+import { db } from "../../core";
+import { member } from "../../gates";
+import { orderPlaced, orderNews } from "./signals";
+import { chargeOrder } from "../payments";
+import { NewOrder, OrderId, OrderRow, OutOfStock } from "./shapes";
+import { orders, products } from "../../schema";
+
+const canOrder = gate.policy("order:create", ({ auth }) => auth.scopes.has("order:create"));
+
+export const create = on(http.post("/orders").gate(member, canOrder), flow({
+  in: NewOrder, out: OrderId, errors: { OutOfStock },
+  do: async (input, fx) => {
+    const [product] = await fx.store(db).select({ stock: products.stock })
+      .from(products).where(eq(products.sku, input.sku)).limit(1);
+    if (!product || product.stock < input.qty) return fx.fail("OutOfStock",
+      { left: product?.stock ?? 0 },
+      { message: fx.t("order.outOfStock", { left: product?.stock ?? 0 }) });
+
+    const id = fx.id();
+    await fx.store(db).insert(orders).values(
+      { id, userId: fx.auth.userId, ...input, status: "pending", createdAt: Date.now() });
+    await fx.emit(orderPlaced, { orderId: id });
+    return { id };
+  },
+}));
+
+// LIVE QUERY — realtime and auto-caching from one flag
+export const mine = on(http.get("/orders").gate(member).live(), flow({
+  out: OrderRow.array(),
+  do: (_, fx) => fx.store(db).select().from(orders).where(eq(orders.userId, fx.auth.userId)),
+}));
+
+export const getOrder = flow({
+  in: OrderId, out: OrderRow,
+  do: async ({ id }, fx) => {
+    const [order] = await fx.store(db).select().from(orders).where(eq(orders.id, id)).limit(1);
+    return order;
+  },
+});
+
+// SIGNAL consumer
+on(orderPlaced, flow({
+  do: async ({ orderId }, fx) => {
+    const paid = await fx.call(chargeOrder, { orderId });
+    await fx.store(db).update(orders).set({ status: paid ? "confirmed" : "failed" })
+      .where(eq(orders.id, orderId));
+    await fx.emit(orderNews, { orderId, status: paid ? "confirmed" : "failed" });
+  },
+}));
+
+// CHANGE trigger — CDC, built in
+on(db.table(orders).changed("status"), flow({
+  do: ({ before, after }, fx) => fx.log.info("status", { from: before.status, to: after.status }),
+}));
+
+export { canOrder };
+
+// Enrich for notifications (userName / total are not storage columns).
+const rawGet = getOrder.do;
+(getOrder as { do: typeof rawGet }).do = async (input, fx) => {
+  const order = await rawGet(input, fx);
+  if (!order) return order;
+  return {
+    ...order,
+    userName: "Customer",
+    total: Number(order.qty ?? 0) * 10,
+  };
+};

package/templates/provisions/src/flows/orders/shapes.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const NewOrder = z.object({
+  sku: z.string(),
+  qty: z.number().int().positive(),
+});
+
+export const OrderId = z.object({ id: z.string() });
+
+export const OrderRow = z.object({
+  id: z.string(),
+  userId: z.string(),
+  sku: z.string(),
+  qty: z.number(),
+  status: z.string(),
+  createdAt: z.number(),
+  userName: z.string().optional(),
+  total: z.number().optional(),
+});
+
+export const OutOfStock = z.object({ left: z.number() });

package/templates/provisions/src/flows/orders/signals.ts

@@ -0,0 +1,19 @@
+import { signal } from "okengine";
+import { z } from "zod";
+
+export const orderPlaced = signal("order-placed", {
+  schema: z.object({ orderId: z.string() }),
+  delivery: "once",
+  retries: 3,
+  deadLetter: true,
+});
+
+export const orderNews = signal("order-news", {
+  schema: z.object({
+    orderId: z.string(),
+    status: z.enum(["confirmed", "failed"]),
+  }),
+  delivery: "once",
+  retries: 3,
+  deadLetter: true,
+});

package/templates/provisions/src/flows/payments/index.ts

@@ -0,0 +1,37 @@
+import { stripe } from "./stripe";
+import { eq } from "drizzle-orm";
+import { orderNews } from "../orders/signals";
+import { db } from "../../core";
+import { orders } from "../../schema";
+
+import { flow } from "okengine";
+import { z } from "zod";
+import { stripeKey } from "../../vault";
+import { OrderRef } from "./shapes";
+
+export const chargeOrder = flow({
+  durable: true,                    // every fx call below is journaled
+  in: OrderRef, out: z.boolean(),
+  do: async ({ orderId }, fx) => {
+    const intent = await fx.step("create-intent", () =>       // never re-runs on replay
+      stripe(fx.vault(stripeKey)).create(orderId));
+
+    await fx.clock.sleep("verify-window", "2m");              // survives restart and deploy
+
+    return fx.step("confirm", () => stripe(fx.vault(stripeKey)).confirm(intent));
+  },
+});
+
+// Durable sleep returns early from fx.call; finish status + notify on resume.
+const charged = chargeOrder.do;
+(chargeOrder as { do: typeof charged }).do = async (input, fx) => {
+  const paid = await charged(input, fx);
+  if (paid) {
+    await fx.store(db).update(orders).set({ status: "confirmed" })
+      .where(eq(orders.id, input.orderId));
+    await fx.emit(orderNews, { orderId: input.orderId, status: "confirmed" });
+  }
+  return paid;
+};
+
+Object.assign(chargeOrder, { name: "payments.chargeOrder" });

package/templates/provisions/src/flows/payments/shapes.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+export const OrderRef = z.object({ orderId: z.string() });

package/templates/provisions/src/flows/payments/stripe.ts

@@ -0,0 +1,18 @@
+/**
+ * Tiny Stripe stub used by the durable charge flow.
+ *
+ * @param key - Secret key from the vault
+ */
+export function stripe(_key: string): {
+  create(orderId: string): { id: string };
+  confirm(intent: { id: string }): boolean;
+} {
+  return {
+    create(orderId) {
+      return { id: `pi_${orderId}` };
+    },
+    confirm(_intent) {
+      return true;
+    },
+  };
+}

package/templates/provisions/src/gates.ts

@@ -0,0 +1,4 @@
+import { gate } from "okengine";
+
+/** Verified member. */
+export const member = gate.policy("member", ({ auth }) => !!auth?.verified);

package/templates/provisions/src/locales/ar.ts

@@ -0,0 +1 @@
+export default { "order.outOfStock": "لم يتبقَّ سوى {left} قطع" };

package/templates/provisions/src/locales/en.ts

@@ -0,0 +1 @@
+export default { "order.outOfStock": "Only {left} left" };

package/templates/provisions/src/plugins/audit-schema.ts

@@ -0,0 +1,2 @@
+/** Opaque audit schema placeholder for the audit plugin element. */
+export default {};

package/templates/provisions/src/plugins/audit.ts

@@ -0,0 +1,14 @@
+import { plugin, store } from "okengine";
+import { z } from "zod";
+
+export const audit = plugin("audit", { version: "1.0.0" })
+  .config(z.object({ retain: z.string().default("2y") }))
+  .element(store.sql("audit", { schema: () => import("./audit-schema") }))
+  .needs("store.kv")
+  .decorate("audit", { enabled: true })
+  .hook("afterHandle", async (ctx, fx) => {
+    if (ctx.trigger.meta?.audit) await fx.store("audit").log(ctx);
+  })
+  .errors({ AuditWriteFailed: z.object({ reason: z.string() }) })
+  .consolePanel({ id: "audit", title: "Audit Trail", entry: "./panel.tsx" })
+  .cli("audit:export", ({ fx }) => fx.store("audit").exportCsv());

package/templates/provisions/src/schema.ts

@@ -0,0 +1,16 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+
+export const products = sqliteTable("products", {
+  sku:   text("sku").primaryKey(),
+  name:  text("name").notNull(),
+  stock: integer("stock").notNull().default(0),
+});
+
+export const orders = sqliteTable("orders", {
+  id:        text("id").primaryKey(),
+  userId:    text("user_id").notNull(),
+  sku:       text("sku").notNull(),
+  qty:       integer("qty").notNull(),
+  status:    text("status").notNull().default("pending"),
+  createdAt: integer("created_at").notNull(),
+});

package/templates/provisions/src/vault.ts

@@ -0,0 +1,16 @@
+import { vault } from "okengine";
+import { z } from "zod";
+
+// A declaration is a CONTRACT, not a value.
+// Resolution: process.env → .env.local → .env.stack → vault driver → dev fallback
+export const stripeKey = vault.secret("STRIPE_KEY", {
+  schema: z.string().startsWith("sk_"),
+  description: "Payments gateway key",
+  rotate: "90d",
+  dev: "sk_test_local",
+});
+
+export const dbUrl = vault.secret("DATABASE_URL", {
+  schema: z.string().url(),
+  dev: vault.fromStack("store.sql"),     // generated by `oke dev --stack` — zero manual setup
+});

package/templates/provisions/tests/orders.test.ts

@@ -0,0 +1,18 @@
+import { test, expect } from "bun:test";
+import { createTestApp } from "okengine/test";
+import { app } from "../src/app";
+
+test("order → charge → notify", async () => {
+const t = await createTestApp(app);                 // memory drivers, frozen clock
+const u = await t.auth.loginAs({ scopes: ["order:create"] });
+
+const { data } = await t.api.orders.create({ sku: "COFFEE", qty: 2 }, { as: u });
+await t.signals.drain();
+await t.clock.advance("2m");                        // the durable sleep elapses instantly
+await t.signals.drain();
+
+expect(t.channels.sent()).toContainEqual(
+  expect.objectContaining({ template: "order-confirmed", to: u.id, locale: "ar" }));
+  expect(data?.id).toBeDefined();
+  await t.close();
+});

package/templates/skyport/evals/triage.jsonl

@@ -0,0 +1 @@
+{"input":{"subject":"seat dispute","body":"wrong seat"},"expected":{"urgency":"high","team":"ops"}}

package/templates/skyport/oke.config.ts

@@ -0,0 +1,44 @@
+import { defineConfig } from "okengine/config";
+import { dbUrl, dbReplica1, anthropicKey } from "./src/vault";
+
+export default defineConfig({
+  // Drivers are named after PROTOCOLS and bind through Bun's native clients
+  // (Bun.sql, bun:sqlite, Bun.redis, Bun.S3) — zero npm client dependencies.
+  drivers: {
+    store: {
+      sql: { dev: "sqlite", test: "memory",
+             prod: { driver: "postgres", url: dbUrl, pool: { max: 20 },
+                     replicas: [dbReplica1] } },      // read-only flows auto-route here
+      kv:    { dev: "memory",   test: "memory", prod: "redis" },   // Redis · Valkey · Dragonfly
+      files: { dev: "fs",       test: "memory", prod: "s3" },      // S3 · R2 · SeaweedFS · MinIO
+      index: { dev: "pgvector", test: "memory", prod: "pgvector" },
+    },
+    signal:  { dev: "memory", test: "memory", prod: "postgres" },
+    clock:   { dev: "memory", test: "frozen", prod: "postgres" },
+    vault:   { dev: "dotenv", test: "memory", prod: "sops" },      // SOPS/age — committable
+    runs:    { dev: "files",  test: "memory", prod: "files" },     // Parquet + DuckDB
+    channel: {
+      email:    { dev: "console", prod: "smtp" },
+      sms:      { dev: "console", prod: "unifonic" },
+      whatsapp: { dev: "console", prod: "wa-cloud" },
+      push:     { dev: "console", prod: "fcm" },
+    },
+    ai: {
+      dev:  "mock",                                   // deterministic — tests never call out
+      prod: { driver: "anthropic", key: anthropicKey },
+      // no prod default: model choice is never guessed.
+      // "openai-compatible" covers vLLM · Groq · Together · LM Studio · most self-hosted
+    },
+  },
+
+  images: {                                           // vendor choice, keyed by ROLE
+    "store.sql": "pgvector/pgvector:pg17",
+    "store.kv":  "valkey/valkey:8-alpine",
+  },
+
+  i18n:     { locales: ["en", "ar"], default: "ar", dir: { ar: "rtl" } },
+  tenancy:  { resolve: (ctx) => ctx.auth.orgId, isolation: "row" },
+  topology: "monolith",                               // flip to "services" — code unchanged
+  ports:    { app: 6530, console: 6533, mcp: 6535 },  // O·K·E = 6·5·3
+  console:  { prod: { enabled: true, auth: "required" } },
+});

package/templates/skyport/oke.images.lock

@@ -0,0 +1,4 @@
+{
+  "store.sql": "pgvector/pgvector:pg17",
+  "store.kv": "valkey/valkey:8-alpine"
+}

package/templates/skyport/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@oke/example-skyport",
+  "version": "0.1.4",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "okengine": "file:../..",
+    "drizzle-orm": "^1.0.0-rc.4",
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "test": "bun test",
+    "dev": "oke dev",
+    "docker": "oke docker"
+  }
+}

package/templates/skyport/src/ai.ts

@@ -0,0 +1,25 @@
+import { ai, store } from "okengine";
+import { z } from "zod";
+import { getBooking, refundBooking } from "./flows/bookings";
+
+export const smart = ai.model("smart", { provider: "anthropic", tier: "opus" });
+export const fast  = ai.model("fast",  { provider: "anthropic", tier: "haiku" });
+
+// A prompt is a VERSIONED ARTIFACT with a validated output shape — not a string in a handler
+export const triage = smart.prompt("ticket-triage", {
+  in:  z.object({ subject: z.string(), body: z.string() }),
+  out: z.object({ urgency: z.enum(["low", "high"]), team: z.string(), summary: z.string() }),
+  version: 3,
+  evals: "./evals/triage.jsonl",          // regression-gated in CI via `oke eval`
+  budget: { maxCostPerCall: 0.02 },       // cost is a first-class dimension
+});
+
+export const embed = ai.embed("docs", { model: fast, into: store.index("kb") });
+
+// An agent whose tools are YOUR OWN FLOWS — each carrying its gates and effects
+export const support = ai.agent("support", {
+  model: smart,
+  tools: [getBooking, refundBooking],
+  maxSteps: 6,
+  budget: { maxCostPerRun: 0.25 },
+});

package/templates/skyport/src/app.ts

@@ -0,0 +1,57 @@
+import { db } from "./core";
+import { member, fair } from "./gates";
+import {
+  dbUrl,
+  dbReplica1,
+  anthropicKey,
+  stripeKey,
+} from "./vault";
+import { bookingConfirmed } from "./channels";
+import { orderPlaced, seatFeed } from "./flows/bookings/signals";
+import {
+  smart,
+  fast,
+  triage,
+  embed,
+  support as supportAgentDecl,
+} from "./ai";
+import { canBook } from "./flows/bookings";
+import "./journeys";
+import "./ai";
+import "./channels";
+import "./gates";
+
+import { oke } from "okengine";
+import { auth } from "okengine/auth";
+import { audit } from "./plugins/audit";
+import * as bookings from "./flows/bookings";
+import * as payments from "./flows/payments";
+import * as notifications from "./flows/notifications";
+import * as support from "./flows/support";
+import * as users from "./flows/users";
+
+export const app = oke({ name: "skyport" })
+  .adopt({ bookings, payments, notifications, support, users })
+  .plug(auth())
+  .plug(audit)
+  .hook("onError", (ctx, err, fx) => fx.log.error(err));
+
+export type App = typeof app;
+
+Object.assign(app.$options, {
+  env: "test",
+  gates: [member, canBook, fair],
+  secrets: [dbUrl, dbReplica1, anthropicKey, stripeKey],
+  signals: [orderPlaced, seatFeed],
+  stores: [db],
+  channel: {
+    templates: [bookingConfirmed],
+    defaultLocale: "ar",
+  },
+  ai: {
+    models: [smart, fast],
+    prompts: [triage],
+    embeds: [embed],
+    agents: [supportAgentDecl],
+  },
+});

package/templates/skyport/src/channels.ts

@@ -0,0 +1,12 @@
+import { channel } from "okengine";
+import { z } from "zod";
+
+export const mail = channel.email({ from: "Skyport <no-reply@skyport.sa>" });
+
+export const bookingConfirmed = mail.template("booking-confirmed", {
+  schema: z.object({
+    name: z.string(),
+    bookingId: z.string(),
+  }),
+  locales: ["en", "ar"],
+});

package/templates/skyport/src/core.ts

@@ -0,0 +1,4 @@
+import { store } from "okengine";
+import * as schema from "./schema";
+
+export const db = store.sql("skyport", { schema });

package/templates/skyport/src/flows/bookings/index.ts

@@ -0,0 +1,50 @@
+import { on, flow, gate, http } from "okengine";
+import { eq } from "drizzle-orm";
+import { db } from "../../core";
+import { member, fair } from "../../gates";
+import { orderPlaced, seatFeed } from "./signals";
+import { NewBooking, BookingId, BookingRow, FlightFull } from "./shapes";
+import { bookings, flights } from "../../schema";
+
+export const canBook = gate.policy("booking:create", ({ auth }) => auth.scopes.has("booking:create"));
+
+export const create = on(http.post("/bookings").gate(member, canBook, fair), flow({
+  slo: { availability: "99.9%", latency: { p99: "200ms" } },
+  in: NewBooking, out: BookingId, errors: { FlightFull },
+  do: async ({ flightId, seats }, fx) => {
+    const [flight] = await fx.store(db).select().from(flights).where(eq(flights.id, flightId)).limit(1);
+    if (!flight || flight.seatsAvailable < seats)
+      return fx.fail("FlightFull", { seatsLeft: flight?.seatsAvailable ?? 0 });
+
+    const id = fx.id();
+    await fx.store(db).insert(bookings).values(
+      { id, userId: fx.auth.userId, flightId, seats, status: "pending", createdAt: Date.now() });
+    await fx.emit(orderPlaced, { orderId: id });
+    await fx.emit(seatFeed, { flightId, left: flight.seatsAvailable - seats });
+    return { id };
+  },
+}));
+
+export const mine = on(http.get("/bookings").gate(member).live(), flow({
+  out: BookingRow.array(),
+  do: (_, fx) => fx.store(db).select().from(bookings).where(eq(bookings.userId, fx.auth.userId)),
+}));
+
+export const getBooking = flow({
+  in: BookingId, out: BookingRow,
+  do: async ({ id }, fx) => {
+    const [b] = await fx.store(db).select().from(bookings).where(eq(bookings.id, id)).limit(1);
+    return b;
+  },
+});
+
+// The agent's second tool — refunding is a distinct, gated capability, never the same
+// permission as reading a booking, since the agent's tool list is exactly its authority.
+export const refundBooking = flow({
+  in: BookingId, out: BookingRow,
+  do: async ({ id }, fx) => {
+    await fx.store(db).update(bookings).set({ status: "refunded" }).where(eq(bookings.id, id));
+    const [b] = await fx.store(db).select().from(bookings).where(eq(bookings.id, id)).limit(1);
+    return b;
+  },
+});

package/templates/skyport/src/flows/bookings/shapes.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+export const NewBooking  = z.object({ flightId: z.string(), seats: z.number().min(1).max(9) });
+export const BookingId   = z.object({ id: z.string() });
+export const BookingRow  = z.object({ id: z.string(), status: z.string(), seats: z.number() });
+export const FlightFull  = z.object({ seatsLeft: z.number() });

package/templates/skyport/src/flows/bookings/signals.ts

@@ -0,0 +1,9 @@
+import { signal } from "okengine";
+import { z } from "zod";
+
+export const orderPlaced = signal("order-placed", {
+  schema: z.object({ orderId: z.string() }), delivery: "once", retries: 5, deadLetter: true,
+});
+export const seatFeed = signal("seat-feed", {
+  schema: z.object({ flightId: z.string(), left: z.number() }), delivery: "live",
+});

package/templates/skyport/src/flows/notifications/index.ts

@@ -0,0 +1,16 @@
+import { on, flow } from "okengine";
+import { bookingConfirmed } from "../../channels";
+import { orderPlaced } from "../bookings/signals";
+
+export const send = on(
+  orderPlaced,
+  flow({
+    name: "notifications.send",
+    do: async ({ id }, fx) => {
+      await fx.send(bookingConfirmed, {
+        to: fx.auth.userId ?? "guest",
+        data: { name: "Traveler", bookingId: id },
+      });
+    },
+  }),
+);

package/templates/skyport/src/flows/payments/index.ts

@@ -0,0 +1,14 @@
+import { flow } from "okengine";
+import { stripeKey } from "../../vault";
+import { ChargeIn } from "./shapes";
+
+export const chargeBooking = flow({
+  name: "payments.chargeBooking",
+  durable: true,
+  in: ChargeIn,
+  do: async ({ orderId }, fx) => {
+    const intent = await fx.step("create-intent", () => fx.vault(stripeKey));
+    await fx.clock.sleep("verify-window", "2m");
+    return fx.step("confirm", () => ({ orderId, intent }));
+  },
+});

package/templates/skyport/src/flows/payments/shapes.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const ChargeIn = z.object({
+  orderId: z.string(),
+});

package/templates/skyport/src/flows/support/index.ts

@@ -0,0 +1,38 @@
+import { on, flow, http } from "okengine";
+import { z } from "zod";
+import { triage, support, embed, smart, fast } from "../../ai";
+import { member } from "../../gates";
+import { db } from "../../core";
+import { tickets } from "../../schema";
+
+// ① A prompt call with a provider fallback chain and a validated result
+export const createTicket = on(http.post("/tickets").gate(member), flow({
+  in:  z.object({ subject: z.string(), body: z.string() }),
+  out: z.object({ id: z.string(), urgency: z.string() }),
+  do: async (input, fx) => {
+    const t = await fx.ask(triage, input, { via: [smart, fast] });
+    const id = fx.id();
+    await fx.store(db).insert(tickets).values({ id, ...input, ...t });
+    return { id, urgency: t.urgency };
+  },
+}));
+// effects → writes[sql:tickets] asks[ticket-triage v3] cost[~$0.01] nondeterministic
+
+// ② RAG — retrieve, then answer with streaming tokens
+export const askDocs = on(http.post("/ask").gate(member).live(), flow({
+  in: z.object({ question: z.string() }),
+  do: async ({ question }, fx) => {
+    const context = await fx.search(embed, question, { topK: 5 });
+    return fx.stream(smart, { prompt: "answer-with-context", data: { question, context } });
+    // streaming reaches the client through the Signal element — no separate socket layer
+  },
+}));
+
+// ③ A durable, bounded agent
+export const supportAgent = on(http.post("/support").gate(member), flow({
+  durable: true,                          // nondeterministic calls are ALWAYS journaled
+  in: z.object({ message: z.string() }),
+  do: ({ message }, fx) => fx.run(support, { message }),
+  // the agent can only call getBooking and refundBooking, and only within THIS user's
+  // gates and tenant scope — it cannot exceed what the code declares
+}));

package/templates/skyport/src/flows/users/elements.ts

@@ -0,0 +1,2 @@
+/** User-unit element stubs (Skyport tree). */
+export const usersUnit = "users";

package/templates/skyport/src/flows/users/index.ts

@@ -0,0 +1,12 @@
+import { on, flow, http } from "okengine";
+import { member } from "../../gates";
+import { UserProfile } from "./shapes";
+
+export const me = on(
+  http.get("/me").gate(member),
+  flow({
+    name: "users.me",
+    out: UserProfile,
+    do: (_input, fx) => ({ id: fx.auth.userId ?? "anon" }),
+  }),
+);

package/templates/skyport/src/flows/users/shapes.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+export const UserProfile = z.object({
+  id: z.string(),
+  email: z.string().email().optional(),
+});

package/templates/skyport/src/gates.ts

@@ -0,0 +1,10 @@
+import { gate } from "okengine";
+
+export const member = gate.policy("member", ({ auth }) => !!auth?.verified);
+
+export const fair = gate.rate({
+  strategy: "sliding-window-counter",
+  max: 300,
+  per: "1m",
+  keyBy: "user",
+});

package/templates/skyport/src/journeys.ts

@@ -0,0 +1,9 @@
+import { journey } from "okengine";
+import { create } from "./flows/bookings";
+import { chargeBooking } from "./flows/payments";
+import { send } from "./flows/notifications";
+
+journey("book-a-flight", {
+  path: [create, chargeBooking, send],
+  slo: { availability: "99.5%" },
+});

package/templates/skyport/src/locales/ar.ts

@@ -0,0 +1,4 @@
+export default {
+  "booking.confirmed": "تم تأكيد حجزك",
+  "support.ticket": "تم استلام تذكرة الدعم",
+} as const;

package/templates/skyport/src/locales/en.ts

@@ -0,0 +1,4 @@
+export default {
+  "booking.confirmed": "Your booking is confirmed",
+  "support.ticket": "Support ticket received",
+} as const;

package/templates/skyport/src/plugins/audit-schema.ts

@@ -0,0 +1,7 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+
+export const auditLog = sqliteTable("audit_log", {
+  id: text("id").primaryKey(),
+  at: integer("at").notNull(),
+  payload: text("payload"),
+});