@nilejs/nile 0.0.1

package/dist/index.js

@@ -0,0 +1,1411 @@
+// src/engine/create-action.ts
+function createAction(config) {
+  return config;
+}
+function createActions(configs) {
+  return configs;
+}
+
+// src/engine/create-service.ts
+function createService(config) {
+  return config;
+}
+function createServices(configs) {
+  return configs;
+}
+
+// src/logging/logger.ts
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync
+} from "fs";
+import { join } from "path";
+import { nanoid } from "nanoid";
+import pino from "pino";
+var getMode = () => {
+  if (!process.env.MODE) {
+    throw new Error("Missing MODE environment variable");
+  }
+  return process.env.MODE;
+};
+var logDir = join(process.cwd(), "logs");
+if (!existsSync(logDir)) {
+  mkdirSync(logDir);
+}
+var MONTHLY_PATTERN = /^(\d{4})-(\d{2})$/;
+var DAILY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+var WEEKLY_PATTERN = /^(\d{4})-W(\d{2})$/;
+function resolveLogPath(appName, config) {
+  const chunking = config?.chunking ?? "none";
+  if (chunking === "none") {
+    return join(logDir, `${appName}.log`);
+  }
+  const appDir = join(logDir, appName);
+  if (!existsSync(appDir)) {
+    mkdirSync(appDir, { recursive: true });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const chunk = formatChunkName(now, chunking);
+  return join(appDir, `${chunk}.log`);
+}
+function formatChunkName(date, chunking) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  if (chunking === "monthly") {
+    return `${year}-${month}`;
+  }
+  if (chunking === "daily") {
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+  }
+  const weekNum = getISOWeekNumber(date);
+  return `${year}-W${String(weekNum).padStart(2, "0")}`;
+}
+function getISOWeekNumber(date) {
+  const target = new Date(date.valueOf());
+  const dayNum = target.getDay() || 7;
+  target.setDate(target.getDate() + 4 - dayNum);
+  const yearStart = new Date(target.getFullYear(), 0, 1);
+  return Math.ceil(
+    ((target.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
+  );
+}
+function createLoggerForApp(appName, config) {
+  const logFile = resolveLogPath(appName, config);
+  const transport = pino.transport({
+    targets: [
+      {
+        level: "info",
+        target: "pino/file",
+        options: {
+          destination: logFile,
+          mkdir: true
+        }
+      }
+    ]
+  });
+  return pino(
+    {
+      base: null,
+      timestamp: () => `,"time":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+      formatters: {
+        level(label) {
+          return { level: label };
+        }
+      }
+    },
+    transport
+  );
+}
+var createLog = (log, config) => {
+  if (!log.appName) {
+    throw new Error(`Missing appName in log: ${JSON.stringify(log)}`);
+  }
+  const level = log.level || "info";
+  const log_id = log.log_id || nanoid(6);
+  const logRecord = {
+    log_id,
+    appName: log.appName,
+    atFunction: log.atFunction,
+    message: log.message,
+    data: log.data ?? null,
+    level,
+    time: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const mode = getMode();
+  if (mode === "prod" || process.env.NODE_ENV === "test") {
+    const logFile = resolveLogPath(log.appName, config);
+    if (process.env.NODE_ENV === "test") {
+      appendFileSync(logFile, `${JSON.stringify(logRecord)}
+`, "utf-8");
+    } else {
+      const appLogger = createLoggerForApp(log.appName, config);
+      appLogger[level](logRecord);
+    }
+    return log_id;
+  }
+  if (mode === "agentic") {
+    return JSON.stringify(logRecord);
+  }
+  console.log({
+    ...logRecord,
+    data: JSON.stringify(logRecord.data, null, 2)
+  });
+  return "dev-mode, see your dev console!";
+};
+var getLogs = (filters = {}, config) => {
+  const chunking = config?.chunking ?? "none";
+  const filesToRead = resolveLogFiles(filters, chunking);
+  const logs = readAndParseLogFiles(filesToRead);
+  return applyLogFilters(logs, filters);
+};
+function resolveLogFiles(filters, chunking) {
+  if (chunking === "none") {
+    const logFile = filters.appName ? join(logDir, `${filters.appName}.log`) : join(logDir, "app.log");
+    return existsSync(logFile) ? [logFile] : [];
+  }
+  if (!filters.appName) {
+    return [];
+  }
+  const appDir = join(logDir, filters.appName);
+  if (!existsSync(appDir)) {
+    return [];
+  }
+  const allFiles = readdirSync(appDir).filter((f) => f.endsWith(".log")).sort();
+  if (!(filters.from || filters.to)) {
+    return allFiles.map((f) => join(appDir, f));
+  }
+  return allFiles.filter((filename) => isChunkRelevant(filename, chunking, filters)).map((f) => join(appDir, f));
+}
+function isChunkRelevant(filename, chunking, filters) {
+  const chunkName = filename.replace(".log", "");
+  const range = getChunkDateRange(chunkName, chunking);
+  if (!range) {
+    return true;
+  }
+  const { start, end } = range;
+  if (filters.to && start > filters.to) {
+    return false;
+  }
+  if (filters.from && end < filters.from) {
+    return false;
+  }
+  return true;
+}
+function getChunkDateRange(chunkName, chunking) {
+  if (chunking === "monthly") {
+    const match2 = chunkName.match(MONTHLY_PATTERN);
+    if (!(match2?.[1] && match2[2])) {
+      return null;
+    }
+    const year2 = Number(match2[1]);
+    const month = Number(match2[2]) - 1;
+    const start2 = new Date(year2, month, 1);
+    const end2 = new Date(year2, month + 1, 0, 23, 59, 59, 999);
+    return { start: start2, end: end2 };
+  }
+  if (chunking === "daily") {
+    const match2 = chunkName.match(DAILY_PATTERN);
+    if (!(match2?.[1] && match2[2] && match2[3])) {
+      return null;
+    }
+    const year2 = Number(match2[1]);
+    const month = Number(match2[2]) - 1;
+    const day = Number(match2[3]);
+    const start2 = new Date(year2, month, day);
+    const end2 = new Date(year2, month, day, 23, 59, 59, 999);
+    return { start: start2, end: end2 };
+  }
+  const match = chunkName.match(WEEKLY_PATTERN);
+  if (!(match?.[1] && match[2])) {
+    return null;
+  }
+  const year = Number(match[1]);
+  const week = Number(match[2]);
+  const start = getDateFromISOWeek(year, week);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 6);
+  end.setHours(23, 59, 59, 999);
+  return { start, end };
+}
+function getDateFromISOWeek(year, week) {
+  const jan4 = new Date(year, 0, 4);
+  const dayOfWeek = jan4.getDay() || 7;
+  const monday = new Date(jan4);
+  monday.setDate(jan4.getDate() - dayOfWeek + 1);
+  monday.setDate(monday.getDate() + (week - 1) * 7);
+  monday.setHours(0, 0, 0, 0);
+  return monday;
+}
+function readAndParseLogFiles(files) {
+  const logs = [];
+  for (const file of files) {
+    if (!existsSync(file)) {
+      continue;
+    }
+    const content = readFileSync(file, "utf-8").trim();
+    if (!content) {
+      continue;
+    }
+    const lines = content.split("\n");
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        logs.push(parsed);
+      } catch {
+      }
+    }
+  }
+  return logs;
+}
+function applyLogFilters(logs, filters) {
+  return logs.filter((log) => {
+    if (filters.appName && log.appName !== filters.appName) {
+      return false;
+    }
+    if (filters.log_id && log.log_id !== filters.log_id) {
+      return false;
+    }
+    if (filters.level && log.level !== filters.level) {
+      return false;
+    }
+    const time = new Date(log.time);
+    if (filters.from && time < filters.from) {
+      return false;
+    }
+    if (filters.to && time > filters.to) {
+      return false;
+    }
+    return true;
+  });
+}
+
+// src/logging/create-log.ts
+var createLogger = (appName, config) => {
+  return {
+    info: (input) => createLog({ ...input, appName, level: "info" }, config),
+    warn: (input) => createLog({ ...input, appName, level: "warn" }, config),
+    error: (input) => createLog({ ...input, appName, level: "error" }, config)
+  };
+};
+
+// src/nile/server.ts
+import { safeTry as safeTry4 } from "slang-ts";
+
+// src/engine/engine.ts
+import { Err as Err3, Ok as Ok3 } from "slang-ts";
+
+// src/utils/db/create-model.ts
+import { count, desc, eq, lt } from "drizzle-orm";
+import { Ok, safeTry } from "slang-ts";
+
+// src/utils/handle-error.ts
+import { Err } from "slang-ts";
+var CALLER_LINE_REGEX = /at\s+(\S+)\s+/;
+function inferCallerName() {
+  const _err = new Error("capture stack trace");
+  const stack = _err.stack;
+  const callerLine = stack?.split("\n")[3] ?? "";
+  const match = callerLine.match(CALLER_LINE_REGEX);
+  return match?.[1] ?? "unknown";
+}
+function resolveLogger(explicit) {
+  if (explicit) {
+    return explicit;
+  }
+  try {
+    const ctx = getContext();
+    if (ctx.resources?.logger) {
+      return ctx.resources.logger;
+    }
+  } catch (_) {
+  }
+  throw new Error(
+    "handleError: No logger available. Provide a logger param or set resources.logger on server config."
+  );
+}
+function handleError(params) {
+  const atFunction = params.atFunction ?? inferCallerName();
+  const logger = resolveLogger(params.logger);
+  const logId = logger.error({
+    atFunction,
+    message: params.message,
+    data: params.data
+  });
+  return Err(`[${logId}] ${params.message}`);
+}
+
+// src/utils/db/create-transaction-variant.ts
+function createTransactionVariant(fn) {
+  return async (params) => {
+    const { dbx, ...rest } = params;
+    if (!dbx) {
+      const result2 = await fn(params);
+      if (result2.isErr) {
+        throw new Error(String(result2.error));
+      }
+      return result2;
+    }
+    const hasTransaction = typeof dbx?.transaction === "function";
+    if (hasTransaction) {
+      return await dbx.transaction(async (tx) => {
+        const result2 = await fn({ ...rest, dbx: tx });
+        if (result2.isErr) {
+          throw new Error(String(result2.error));
+        }
+        return result2;
+      });
+    }
+    const result = await fn({ ...rest, dbx });
+    if (result.isErr) {
+      throw new Error(String(result.error));
+    }
+    return result;
+  };
+}
+
+// src/utils/db/get-zod-schema.ts
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from "drizzle-zod";
+function getZodSchema(table) {
+  const isRelation = Object.hasOwn(table, "config") && Object.hasOwn(table, "table");
+  if (isRelation) {
+    throw new Error(
+      `${String(table)} is a relation schema, not a table schema`
+    );
+  }
+  const insertSchema = createInsertSchema(
+    table
+  );
+  const updateSchema = createUpdateSchema(
+    table
+  );
+  const selectSchema = createSelectSchema(
+    table
+  );
+  return {
+    insert: insertSchema,
+    update: updateSchema,
+    select: selectSchema
+  };
+}
+
+// src/utils/db/create-model.ts
+function asDb(db) {
+  return db;
+}
+function resolveDb(explicitDb) {
+  if (explicitDb) {
+    return explicitDb;
+  }
+  try {
+    const ctx = getContext();
+    if (ctx.resources?.database) {
+      return ctx.resources.database;
+    }
+  } catch (_) {
+  }
+  throw new Error(
+    "createModel: No database available. Pass db in ModelOptions or set resources.database on server config."
+  );
+}
+function findTimestampColumn(table) {
+  if ("created_at" in table) {
+    return "created_at";
+  }
+  if ("createdAt" in table) {
+    return "createdAt";
+  }
+  return null;
+}
+function createModel(table, options) {
+  const { name, cursorColumn = "id" } = options;
+  const entityName = name.charAt(0).toUpperCase() + name.slice(1);
+  const schemas = getZodSchema(table);
+  const tableRef = table;
+  const getDb = () => asDb(resolveDb(options.db));
+  const create = async ({ data, dbx }) => {
+    const parsed = schemas.insert.safeParse(data);
+    if (!parsed.success) {
+      return handleError({
+        message: `Invalid ${name} data`,
+        data: { errors: parsed.error },
+        atFunction: `${name}.create`
+      });
+    }
+    const db = dbx ? asDb(dbx) : getDb();
+    const result = await safeTry(
+      () => db.insert(table).values(data).returning()
+    );
+    if (result.isErr) {
+      return handleError({
+        message: `Error creating ${name}`,
+        data: { error: result.error },
+        atFunction: `${name}.create`
+      });
+    }
+    const row = result.value?.[0] ?? null;
+    if (!row) {
+      return handleError({
+        message: `${entityName} creation returned no data`,
+        atFunction: `${name}.create`
+      });
+    }
+    return Ok(row);
+  };
+  const update = async ({ id, data, dbx }) => {
+    const parsed = schemas.update.safeParse(data);
+    if (!parsed.success) {
+      return handleError({
+        message: `Invalid ${name} data`,
+        data: { errors: parsed.error },
+        atFunction: `${name}.update`
+      });
+    }
+    const db = dbx ? asDb(dbx) : getDb();
+    const idCol = tableRef.id;
+    const result = await safeTry(
+      () => db.update(table).set(data).where(eq(idCol, id)).returning()
+    );
+    if (result.isErr) {
+      return handleError({
+        message: `Error updating ${name}`,
+        data: { id, error: result.error },
+        atFunction: `${name}.update`
+      });
+    }
+    const row = result.value?.[0] ?? null;
+    if (!row) {
+      return handleError({
+        message: `${entityName} not found`,
+        data: { id },
+        atFunction: `${name}.update`
+      });
+    }
+    return Ok(row);
+  };
+  const createTx = createTransactionVariant(
+    create
+  );
+  const updateTx = createTransactionVariant(
+    update
+  );
+  const findById = async (id) => {
+    const db = getDb();
+    const idCol = tableRef.id;
+    const result = await safeTry(
+      () => db.select().from(table).where(eq(idCol, id))
+    );
+    if (result.isErr) {
+      return handleError({
+        message: `Error getting ${name}`,
+        data: { id, error: result.error },
+        atFunction: `${name}.findById`
+      });
+    }
+    const row = result.value?.[0] ?? null;
+    if (!row) {
+      return handleError({
+        message: `${entityName} not found`,
+        data: { id },
+        atFunction: `${name}.findById`
+      });
+    }
+    return Ok(row);
+  };
+  const deleteFn = async (id) => {
+    const db = getDb();
+    const idCol = tableRef.id;
+    const result = await safeTry(
+      () => db.delete(table).where(eq(idCol, id)).returning()
+    );
+    if (result.isErr) {
+      return handleError({
+        message: `Error deleting ${name}`,
+        data: { id, error: result.error },
+        atFunction: `${name}.delete`
+      });
+    }
+    const row = result.value?.[0] ?? null;
+    if (!row) {
+      return handleError({
+        message: `${entityName} not found`,
+        data: { id },
+        atFunction: `${name}.delete`
+      });
+    }
+    return Ok(row);
+  };
+  const findAll = async () => {
+    const db = getDb();
+    const tsCol = findTimestampColumn(tableRef);
+    const result = await safeTry(() => {
+      const query = db.select().from(table);
+      if (!tsCol) {
+        return query;
+      }
+      return query.orderBy(desc(tableRef[tsCol]));
+    });
+    if (result.isErr) {
+      return handleError({
+        message: `Error getting all ${name}s`,
+        data: { error: result.error },
+        atFunction: `${name}.findAll`
+      });
+    }
+    return Ok(result.value ?? []);
+  };
+  const findOffsetPage = async (limit, offset) => {
+    const db = getDb();
+    const tsCol = findTimestampColumn(tableRef);
+    const itemsResult = await safeTry(() => {
+      const query = db.select().from(table);
+      const ordered = tsCol ? query.orderBy(desc(tableRef[tsCol])) : query;
+      return ordered.limit(limit).offset(offset);
+    });
+    if (itemsResult.isErr) {
+      return handleError({
+        message: `Error getting paginated ${name}s`,
+        data: { limit, offset, error: itemsResult.error },
+        atFunction: `${name}.findPaginated`
+      });
+    }
+    const countResult = await safeTry(
+      () => db.select({ total: count() }).from(table)
+    );
+    if (countResult.isErr) {
+      return handleError({
+        message: `Error getting ${name} count`,
+        data: { error: countResult.error },
+        atFunction: `${name}.findPaginated`
+      });
+    }
+    const items = itemsResult.value ?? [];
+    const total = countResult.value?.[0]?.total ?? 0;
+    return Ok({
+      items,
+      total,
+      hasMore: offset + items.length < total
+    });
+  };
+  const findCursorPage = async (limit, cursor, colName) => {
+    const db = getDb();
+    const column = tableRef[colName];
+    if (!column) {
+      return handleError({
+        message: `Cursor column '${colName}' does not exist on ${name} table`,
+        atFunction: `${name}.findPaginated`
+      });
+    }
+    const typedColumn = column;
+    const result = await safeTry(
+      () => db.select().from(table).where(lt(typedColumn, cursor)).orderBy(desc(typedColumn)).limit(limit + 1)
+    );
+    if (result.isErr) {
+      return handleError({
+        message: `Error getting paginated ${name}s`,
+        data: { cursor, cursorColumn: colName, error: result.error },
+        atFunction: `${name}.findPaginated`
+      });
+    }
+    const rows = result.value ?? [];
+    const hasMore = rows.length > limit;
+    const items = hasMore ? rows.slice(0, limit) : rows;
+    const lastItem = items.at(-1);
+    const nextCursor = lastItem ? String(lastItem[colName] ?? "") || null : null;
+    return Ok({
+      items,
+      nextCursor,
+      hasMore
+    });
+  };
+  const findPaginated = (opts = {}) => {
+    const limit = opts.limit ?? 50;
+    if ("cursor" in opts && opts.cursor) {
+      const colName = opts.cursorColumn ?? cursorColumn;
+      return findCursorPage(limit, opts.cursor, colName);
+    }
+    const offset = opts.offset ?? 0;
+    return findOffsetPage(limit, offset);
+  };
+  return {
+    create,
+    createTx,
+    findById,
+    update,
+    updateTx,
+    delete: deleteFn,
+    findAll,
+    findPaginated,
+    table,
+    schemas
+  };
+}
+
+// src/utils/diagnostics-log.ts
+function isNileLogger(logger) {
+  return "warn" in logger && "error" in logger;
+}
+function createDiagnosticsLog(prefix, params) {
+  if (!params.diagnostics) {
+    return () => {
+    };
+  }
+  const { logger } = params;
+  return (message, data) => {
+    if (!logger) {
+      console.log(`[${prefix}] ${message}`, data ?? "");
+      return;
+    }
+    if (isNileLogger(logger)) {
+      logger.info({
+        atFunction: prefix,
+        message: `[${prefix}] ${message}`,
+        data
+      });
+    } else {
+      logger.info(`[${prefix}] ${message}`, data);
+    }
+  };
+}
+
+// src/engine/pipeline.ts
+import { Err as Err2, Ok as Ok2, safeTry as safeTry2 } from "slang-ts";
+import { prettifyError } from "zod";
+async function runHook(hookDef, hookAction, input, nileContext) {
+  const result = await safeTry2(
+    () => hookAction.handler(input, nileContext)
+  );
+  return {
+    result,
+    logEntry: {
+      name: `${hookDef.service}.${hookDef.action}`,
+      input,
+      output: result.isOk ? result.value : result.error,
+      passed: result.isOk
+    }
+  };
+}
+async function processHooks(hooks, initialValue, getAction, nileContext, logTarget, log) {
+  let currentValue = initialValue;
+  for (const hookDef of hooks) {
+    const hookActionResult = getAction(hookDef.service, hookDef.action);
+    if (hookActionResult.isErr) {
+      const errorMsg = `${logTarget} hook '${hookDef.service}.${hookDef.action}' not found`;
+      log(errorMsg);
+      if (hookDef.isCritical) {
+        nileContext.setHookError(errorMsg);
+        return Err2(errorMsg);
+      }
+      continue;
+    }
+    const { result, logEntry } = await runHook(
+      hookDef,
+      hookActionResult.value,
+      currentValue,
+      nileContext
+    );
+    nileContext.addHookLog(logTarget, logEntry);
+    if (result.isErr) {
+      const errorMsg = String(result.error);
+      log(
+        `${logTarget} hook '${hookDef.service}.${hookDef.action}' failed`,
+        result.error
+      );
+      if (hookDef.isCritical) {
+        nileContext.setHookError(errorMsg);
+        return Err2(errorMsg);
+      }
+      continue;
+    }
+    currentValue = result.value;
+  }
+  return Ok2(currentValue);
+}
+async function runGlobalBeforeHook(handler, nileContext, action, payload, log) {
+  if (!handler) {
+    return Ok2(true);
+  }
+  const result = await safeTry2(() => handler({ nileContext, action, payload }));
+  if (result.isErr) {
+    log(`Global before hook failed for ${action.name}`);
+    nileContext.setHookError(result.error);
+    return Err2(result.error);
+  }
+  return Ok2(true);
+}
+async function runGlobalAfterHook(handler, nileContext, action, payload, currentResult, log) {
+  if (!handler) {
+    return Ok2(currentResult);
+  }
+  const result = await safeTry2(
+    () => handler({
+      nileContext,
+      action,
+      payload,
+      result: Ok2(currentResult)
+    })
+  );
+  if (result.isErr) {
+    log(`Global after hook failed for ${action.name}`);
+    nileContext.setHookError(result.error);
+    return Err2(result.error);
+  }
+  return Ok2(result.value);
+}
+function validatePayload(action, payload, nileContext, log) {
+  if (!action.validation) {
+    return Ok2(payload);
+  }
+  const parseResult = action.validation.safeParse(payload);
+  if (!parseResult.success) {
+    const validationError = prettifyError(parseResult.error);
+    log(`Validation failed for ${action.name}`, validationError);
+    nileContext.setHookError(validationError);
+    return Err2(`Validation failed: ${validationError}`);
+  }
+  return Ok2(parseResult.data);
+}
+async function runHandler(action, payload, nileContext, log) {
+  const result = await safeTry2(
+    () => action.handler(payload, nileContext)
+  );
+  if (result.isErr) {
+    log(`Handler failed for ${action.name}`, result.error);
+    nileContext.setHookError(result.error);
+    return Err2(result.error);
+  }
+  nileContext.setHookOutput(result.value);
+  return Ok2(result.value);
+}
+
+// src/engine/engine.ts
+function createEngine(options) {
+  const { diagnostics, services, logger } = options;
+  const log = createDiagnosticsLog("Engine", {
+    diagnostics,
+    logger
+  });
+  const serviceSummaries = [];
+  const serviceActionsStore = {};
+  const actionStore = {};
+  const initStartTime = performance.now();
+  for (const service of services) {
+    const actionNames = [];
+    serviceActionsStore[service.name] = [];
+    actionStore[service.name] = {};
+    for (const action of service.actions) {
+      actionNames.push(action.name);
+      serviceActionsStore[service.name]?.push({
+        name: action.name,
+        description: action.description,
+        isProtected: !!action.isProtected,
+        validation: !!action.validation,
+        accessControl: action.accessControl || []
+      });
+      const serviceActions = actionStore[service.name];
+      if (serviceActions) {
+        serviceActions[action.name] = action;
+      }
+    }
+    serviceSummaries.push({
+      name: service.name,
+      description: service.description,
+      meta: service.meta,
+      actions: actionNames
+    });
+  }
+  log(
+    `Initialized in ${performance.now() - initStartTime}ms. Loaded ${services.length} services.`
+  );
+  const getServices = () => Ok3(serviceSummaries);
+  const getServiceActions = (serviceName) => {
+    const actions = serviceActionsStore[serviceName];
+    return actions ? Ok3(actions) : Err3(`Service '${serviceName}' not found`);
+  };
+  const getAction = (serviceName, actionName) => {
+    const serviceMap = actionStore[serviceName];
+    if (!serviceMap) {
+      return Err3(`Service '${serviceName}' not found`);
+    }
+    const action = serviceMap[actionName];
+    return action ? Ok3(action) : Err3(`Action '${actionName}' not found in service '${serviceName}'`);
+  };
+  const executeAction = async (serviceName, actionName, payload, nileContext) => {
+    const { onBeforeActionHandler, onAfterActionHandler } = options;
+    const actionResult = getAction(serviceName, actionName);
+    if (actionResult.isErr) {
+      return Err3(actionResult.error);
+    }
+    const action = actionResult.value;
+    nileContext.resetHookContext(`${serviceName}.${actionName}`, payload);
+    const globalBeforeResult = await runGlobalBeforeHook(
+      onBeforeActionHandler,
+      nileContext,
+      action,
+      payload,
+      log
+    );
+    if (globalBeforeResult.isErr) {
+      return Err3(globalBeforeResult.error);
+    }
+    const beforeHooksResult = await processHooks(
+      action.hooks?.before ?? [],
+      payload,
+      getAction,
+      nileContext,
+      "before",
+      log
+    );
+    if (beforeHooksResult.isErr) {
+      return Err3(beforeHooksResult.error);
+    }
+    const validationResult = validatePayload(
+      action,
+      beforeHooksResult.value,
+      nileContext,
+      log
+    );
+    if (validationResult.isErr) {
+      return Err3(validationResult.error);
+    }
+    const handlerResult = await runHandler(
+      action,
+      validationResult.value,
+      nileContext,
+      log
+    );
+    if (handlerResult.isErr) {
+      return Err3(handlerResult.error);
+    }
+    const afterHooksResult = await processHooks(
+      action.hooks?.after ?? [],
+      handlerResult.value,
+      getAction,
+      nileContext,
+      "after",
+      log
+    );
+    if (afterHooksResult.isErr) {
+      return Err3(afterHooksResult.error);
+    }
+    const globalAfterResult = await runGlobalAfterHook(
+      onAfterActionHandler,
+      nileContext,
+      action,
+      validationResult.value,
+      afterHooksResult.value,
+      log
+    );
+    if (globalAfterResult.isErr) {
+      return Err3(globalAfterResult.error);
+    }
+    return action.result?.pipeline ? Ok3({
+      data: globalAfterResult.value,
+      pipeline: nileContext.hookContext.log
+    }) : Ok3(globalAfterResult.value);
+  };
+  return {
+    getServices,
+    getServiceActions,
+    getAction,
+    executeAction
+  };
+}
+
+// src/rest/rest.ts
+import { Hono } from "hono";
+import z2 from "zod";
+
+// src/cors/cors.ts
+import { cors } from "hono/cors";
+var buildDefaultCorsOptions = (config) => {
+  const getDefaultOrigin = (reqOrigin) => {
+    if (config.allowedOrigins.length > 0) {
+      return config.allowedOrigins.includes(reqOrigin ?? "") ? reqOrigin : "";
+    }
+    return "*";
+  };
+  return {
+    origin: config.cors?.defaults?.origin ?? getDefaultOrigin,
+    credentials: config.cors?.defaults?.credentials ?? true,
+    allowHeaders: config.cors?.defaults?.allowHeaders ?? [
+      "Content-Type",
+      "Authorization"
+    ],
+    allowMethods: config.cors?.defaults?.allowMethods ?? [
+      "POST",
+      "GET",
+      "OPTIONS"
+    ],
+    exposeHeaders: config.cors?.defaults?.exposeHeaders ?? ["Content-Length"],
+    maxAge: config.cors?.defaults?.maxAge ?? 600
+  };
+};
+var applyCorsConfig = (app, config) => {
+  const corsEnabled = config.cors?.enabled ?? "default";
+  if (corsEnabled === false) {
+    return;
+  }
+  const defaultCorsOpts = buildDefaultCorsOptions(config);
+  const corsRules = config.cors?.addCors ?? [];
+  for (const rule of corsRules) {
+    applyRouteCorsRule(app, rule, defaultCorsOpts);
+  }
+  app.use("*", cors(defaultCorsOpts));
+};
+var applyRouteCorsRule = (app, rule, defaultOpts) => {
+  if (rule.resolver) {
+    applyResolverBasedCors(app, rule.path, rule.resolver, defaultOpts);
+  } else if (rule.options) {
+    applyStaticCors(app, rule.path, rule.options, defaultOpts);
+  }
+};
+var applyResolverBasedCors = (app, path, resolver, defaultOpts) => {
+  if (!resolver) {
+    return;
+  }
+  app.use(path, (c, next) => {
+    const reqOrigin = c.req.header("origin") ?? "";
+    const corsOpts = evaluateResolver(resolver, reqOrigin, c, defaultOpts);
+    return cors(corsOpts)(c, next);
+  });
+};
+var applyStaticCors = (app, path, options, defaultOpts) => {
+  app.use(
+    path,
+    cors({ ...defaultOpts, ...options })
+  );
+};
+var evaluateResolver = (resolver, origin, c, defaultOpts) => {
+  if (!resolver) {
+    return defaultOpts;
+  }
+  try {
+    const result = resolver(origin, c);
+    if (result === true) {
+      return { ...defaultOpts, origin: origin || "*" };
+    }
+    if (result === false) {
+      return { ...defaultOpts, origin: "" };
+    }
+    if (result && typeof result === "object") {
+      return { ...defaultOpts, ...result };
+    }
+    return defaultOpts;
+  } catch (error) {
+    console.error("CORS resolver error:", error);
+    return { ...defaultOpts, origin: "" };
+  }
+};
+
+// src/rest/intent-handlers.ts
+import { Ok as Ok4 } from "slang-ts";
+import z from "zod";
+function toExternalResponse(result, successMessage) {
+  if (result.isOk) {
+    const value = result.value;
+    const data = value !== null && typeof value === "object" && !Array.isArray(value) ? value : { result: value };
+    return { status: true, message: successMessage, data };
+  }
+  return { status: false, message: result.error, data: {} };
+}
+function handleExplore(engine, request) {
+  const { service, action } = request;
+  if (service === "*") {
+    return toExternalResponse(engine.getServices(), "Available services");
+  }
+  if (action === "*") {
+    return toExternalResponse(
+      engine.getServiceActions(service),
+      `Actions for '${service}'`
+    );
+  }
+  const actionResult = engine.getAction(service, action);
+  if (actionResult.isErr) {
+    return toExternalResponse(actionResult, "");
+  }
+  const act = actionResult.value;
+  return toExternalResponse(
+    Ok4({
+      name: act.name,
+      description: act.description,
+      isProtected: act.isProtected ?? false,
+      accessControl: act.accessControl,
+      hooks: act.hooks ? { before: act.hooks.before ?? [], after: act.hooks.after ?? [] } : null,
+      meta: act.meta ?? null
+    }),
+    `Details for '${service}.${action}'`
+  );
+}
+async function handleExecute(engine, request, nileContext) {
+  const { service, action, payload } = request;
+  if (service === "*" || action === "*") {
+    return {
+      status: false,
+      message: "Execute intent requires specific service and action, wildcards not allowed",
+      data: {}
+    };
+  }
+  const result = await engine.executeAction(
+    service,
+    action,
+    payload,
+    nileContext
+  );
+  return toExternalResponse(result, `Action '${service}.${action}' executed`);
+}
+function handleSchema(engine, request) {
+  const { service, action } = request;
+  if (service === "*") {
+    const servicesResult = engine.getServices();
+    if (servicesResult.isErr) {
+      return toExternalResponse(servicesResult, "");
+    }
+    const schemas = {};
+    for (const svc of servicesResult.value) {
+      const actionsResult = engine.getServiceActions(svc.name);
+      if (actionsResult.isErr) {
+        continue;
+      }
+      schemas[svc.name] = buildServiceSchemas(
+        engine,
+        svc.name,
+        actionsResult.value.map((a) => a.name)
+      );
+    }
+    return toExternalResponse(Ok4(schemas), "All service schemas");
+  }
+  if (action === "*") {
+    const actionsResult = engine.getServiceActions(service);
+    if (actionsResult.isErr) {
+      return toExternalResponse(actionsResult, "");
+    }
+    const schemas = buildServiceSchemas(
+      engine,
+      service,
+      actionsResult.value.map((a) => a.name)
+    );
+    return toExternalResponse(Ok4(schemas), `Schemas for '${service}'`);
+  }
+  const actionResult = engine.getAction(service, action);
+  if (actionResult.isErr) {
+    return toExternalResponse(actionResult, "");
+  }
+  const schema = extractActionSchema(actionResult.value);
+  return toExternalResponse(
+    Ok4({ [action]: schema }),
+    `Schema for '${service}.${action}'`
+  );
+}
+function buildServiceSchemas(engine, serviceName, actionNames) {
+  const schemas = {};
+  for (const actionName of actionNames) {
+    const actionResult = engine.getAction(serviceName, actionName);
+    if (actionResult.isErr) {
+      continue;
+    }
+    schemas[actionName] = extractActionSchema(actionResult.value);
+  }
+  return schemas;
+}
+function extractActionSchema(action) {
+  const schema = action.validation;
+  if (!schema) {
+    return null;
+  }
+  const { err, result } = safeTrySync(
+    () => z.toJSONSchema(schema, { unrepresentable: "any" })
+  );
+  return err ? null : result;
+}
+function safeTrySync(fn) {
+  try {
+    return { err: null, result: fn() };
+  } catch (error) {
+    return { err: error, result: null };
+  }
+}
+var intentHandlers = {
+  explore: (engine, request) => handleExplore(engine, request),
+  execute: (engine, request, nileContext) => handleExecute(engine, request, nileContext),
+  schema: (engine, request) => handleSchema(engine, request)
+};
+
+// src/rest/middleware.ts
+import { rateLimiter } from "hono-rate-limiter";
+import { safeTry as safeTry3 } from "slang-ts";
+var ASSETS_REGEX = /^\/assets\//;
+var DEFAULT_RATE_LIMIT_WINDOW_MS = 15 * 60 * 1e3;
+var DEFAULT_RATE_LIMIT_MAX = 100;
+var UNKNOWN_CLIENT_KEY = "__unknown_client__";
+function applyRateLimiting(app, config, log) {
+  if (!config.rateLimiting?.limitingHeader) {
+    return;
+  }
+  const { rateLimiting } = config;
+  app.use(
+    rateLimiter({
+      windowMs: rateLimiting.windowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS,
+      limit: rateLimiting.limit ?? DEFAULT_RATE_LIMIT_MAX,
+      standardHeaders: rateLimiting.standardHeaders ?? true,
+      keyGenerator: (c) => {
+        const key = c.req.header(rateLimiting.limitingHeader);
+        if (!key) {
+          log(
+            `Rate limiting header '${rateLimiting.limitingHeader}' missing from request`
+          );
+          return UNKNOWN_CLIENT_KEY;
+        }
+        return key;
+      },
+      store: rateLimiting.store ?? void 0
+    })
+  );
+  log(
+    `Rate limiting enabled: ${rateLimiting.limit ?? DEFAULT_RATE_LIMIT_MAX} requests per ${rateLimiting.windowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS}ms window`
+  );
+}
+function applyStaticServing(app, config, runtime, log) {
+  if (!config.enableStatic) {
+    return;
+  }
+  if (runtime !== "bun") {
+    log(`Static file serving not yet supported for runtime: ${runtime}`);
+    return;
+  }
+  let cachedHandler = null;
+  let importFailed = false;
+  app.use("/assets/*", async (c, next) => {
+    if (importFailed) {
+      return next();
+    }
+    if (!cachedHandler) {
+      const importResult = await safeTry3(async () => {
+        const mod = await import("hono/bun");
+        return mod.serveStatic({
+          root: "./assets",
+          rewriteRequestPath: (path) => path.replace(ASSETS_REGEX, "")
+        });
+      });
+      if (importResult.isErr) {
+        log("Failed to load static file adapter", importResult.error);
+        importFailed = true;
+        return next();
+      }
+      cachedHandler = importResult.value;
+    }
+    if (cachedHandler) {
+      return cachedHandler(c, next);
+    }
+  });
+  log("Static file serving enabled at /assets/*");
+}
+
+// src/rest/rest.ts
+var externalRequestSchema = z2.object({
+  intent: z2.enum(["explore", "execute", "schema"]),
+  service: z2.string().min(1),
+  action: z2.string().min(1),
+  payload: z2.record(z2.string(), z2.unknown())
+});
+function createRestApp(params) {
+  const { config, engine, nileContext, serverName, runtime } = params;
+  const app = new Hono();
+  const log = createDiagnosticsLog("REST", {
+    diagnostics: config.diagnostics,
+    logger: nileContext.resources?.logger
+  });
+  applyCorsConfig(app, config);
+  applyRateLimiting(app, config, log);
+  applyStaticServing(app, config, runtime, log);
+  const servicesPath = `${config.baseUrl}/services`;
+  app.post(servicesPath, async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body) {
+      return c.json(
+        {
+          status: false,
+          message: "Invalid or missing JSON body",
+          data: {}
+        },
+        400
+      );
+    }
+    const parsed = externalRequestSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json(
+        {
+          status: false,
+          message: "Invalid request format",
+          data: { errors: parsed.error.issues }
+        },
+        400
+      );
+    }
+    const request = parsed.data;
+    log(`${request.intent} -> ${request.service}.${request.action}`);
+    const handler = intentHandlers[request.intent];
+    const response = await handler(engine, request, nileContext);
+    const statusCode = response.status ? 200 : 400;
+    return c.json(response, statusCode);
+  });
+  if (config.enableStatus) {
+    app.get("/status", (c) => {
+      return c.json({
+        status: true,
+        message: `${serverName} is running`,
+        data: {}
+      });
+    });
+  }
+  app.notFound((c) => {
+    return c.json(
+      {
+        status: false,
+        message: `Route not found. Use POST ${servicesPath} for all operations.`,
+        data: {}
+      },
+      404
+    );
+  });
+  log(`REST interface ready at ${servicesPath}`);
+  return app;
+}
+
+// src/nile/nile.ts
+function createNileContext(params) {
+  const store = /* @__PURE__ */ new Map();
+  const interfaceContext = params?.interfaceContext;
+  const sessions = {};
+  const context = {
+    rest: interfaceContext?.rest,
+    ws: interfaceContext?.ws,
+    rpc: interfaceContext?.rpc,
+    resources: params?.resources,
+    sessions,
+    _store: store,
+    get(key) {
+      return store.get(key);
+    },
+    set(key, value) {
+      store.set(key, value);
+    },
+    getSession(name) {
+      return sessions[name];
+    },
+    setSession(name, data) {
+      sessions[name] = data;
+    },
+    hookContext: {
+      actionName: "",
+      input: null,
+      state: {},
+      log: { before: [], after: [] }
+    },
+    updateHookState(key, value) {
+      context.hookContext.state[key] = value;
+    },
+    addHookLog(phase, logEntry) {
+      context.hookContext.log[phase].push(logEntry);
+    },
+    setHookError(error) {
+      context.hookContext.error = error;
+    },
+    setHookOutput(output) {
+      context.hookContext.output = output;
+    },
+    resetHookContext(actionName, input) {
+      context.hookContext = {
+        actionName,
+        input,
+        state: {},
+        log: { before: [], after: [] }
+      };
+    }
+  };
+  return context;
+}
+
+// src/nile/server.ts
+var _nileContext = null;
+function getContext() {
+  if (!_nileContext) {
+    throw new Error(
+      "getContext: Server not initialized. Call createNileServer first."
+    );
+  }
+  return _nileContext;
+}
+function createNileServer(config) {
+  if (!config.services?.length) {
+    throw new Error(
+      "createNileServer requires at least one service in config.services"
+    );
+  }
+  const log = createDiagnosticsLog("NileServer", {
+    diagnostics: config.diagnostics,
+    logger: config.resources?.logger
+  });
+  const nileContext = createNileContext({
+    resources: config.resources
+  });
+  _nileContext = nileContext;
+  const engine = createEngine({
+    services: config.services,
+    diagnostics: config.diagnostics,
+    logger: config.resources?.logger,
+    onBeforeActionHandler: config.onBeforeActionHandler,
+    onAfterActionHandler: config.onAfterActionHandler
+  });
+  log(`Engine initialized with ${config.services.length} service(s)`);
+  if (config.logServices !== false) {
+    const servicesResult = engine.getServices();
+    if (servicesResult.isOk) {
+      const table = servicesResult.value.map((s) => ({
+        Service: s.name,
+        Description: s.description,
+        Actions: s.actions.length
+      }));
+      console.table(table);
+    }
+  }
+  const server = {
+    config,
+    engine,
+    context: nileContext
+  };
+  if (config.rest) {
+    const app = createRestApp({
+      config: config.rest,
+      engine,
+      nileContext,
+      serverName: config.serverName,
+      runtime: config.runtime ?? "bun"
+    });
+    server.rest = { app, config: config.rest };
+    const host = config.rest.host ?? "localhost";
+    const port = config.rest.port ?? 3e3;
+    const base = `http://${host}:${port}`;
+    console.log(`
+  POST ${base}${config.rest.baseUrl}/services`);
+    if (config.rest.enableStatus) {
+      console.log(`  GET  ${base}/status`);
+    }
+    console.log("");
+  }
+  if (config.onBoot) {
+    const { fn } = config.onBoot;
+    const _boot = (async () => {
+      const result = await safeTry4(() => fn(nileContext));
+      if (result.isErr) {
+        console.error("[NileServer] onBoot failed:", result.error);
+      }
+    })();
+    _boot;
+  }
+  log(`${config.serverName} server ready`);
+  return server;
+}
+export {
+  createAction,
+  createActions,
+  createLog,
+  createLogger,
+  createModel,
+  createNileServer,
+  createService,
+  createServices,
+  createTransactionVariant,
+  getContext,
+  getLogs,
+  getZodSchema,
+  handleError
+};
+//# sourceMappingURL=index.js.map