@delali/sirannon-db 0.1.6 → 0.1.7

package/dist/chunk-VLTICJOD.mjs

@@ -0,0 +1,470 @@
+import { BackupError } from './chunk-YPYVQJ4C.mjs';
+import { existsSync, mkdirSync, rmSync, readdirSync, lstatSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+
+var BACKUP_FILE_PREFIX = "backup";
+function hasControlCharacters(s) {
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code <= 31) return true;
+  }
+  return false;
+}
+var BackupManager = class {
+  async backup(conn, destPath) {
+    if (hasControlCharacters(destPath)) {
+      throw new BackupError("Backup path contains invalid characters");
+    }
+    const segments = destPath.split(/[/\\]/);
+    if (segments.includes("..")) {
+      throw new BackupError("Backup path must not contain directory traversal segments");
+    }
+    const resolved = resolve(destPath);
+    const dir = dirname(resolved);
+    if (!existsSync(dir)) {
+      try {
+        mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        throw new BackupError(
+          `Failed to create backup directory '${dir}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    if (existsSync(resolved)) {
+      throw new BackupError(`Backup destination '${destPath}' already exists`);
+    }
+    const escaped = resolved.replace(/'/g, "''");
+    try {
+      await conn.exec(`VACUUM INTO '${escaped}'`);
+    } catch (err) {
+      try {
+        rmSync(resolved, { force: true });
+      } catch {
+      }
+      throw new BackupError(`Backup to '${destPath}' failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  generateFilename() {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    return `${BACKUP_FILE_PREFIX}-${ts}.db`;
+  }
+  rotate(dir, maxFiles) {
+    if (maxFiles <= 0) return;
+    const resolved = resolve(dir);
+    if (!existsSync(resolved)) return;
+    let entries;
+    try {
+      entries = readdirSync(resolved).filter((f) => f.startsWith(`${BACKUP_FILE_PREFIX}-`) && f.endsWith(".db")).map((f) => {
+        const filePath = join(resolved, f);
+        return { path: filePath, mtimeMs: lstatSync(filePath).mtimeMs };
+      }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+    } catch (err) {
+      throw new BackupError(
+        `Failed to list backup files in '${dir}': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    for (const entry of entries.slice(maxFiles)) {
+      try {
+        rmSync(entry.path, { force: true });
+      } catch {
+      }
+    }
+  }
+};
+
+// src/core/backup/cron.ts
+var MONTH_NAMES = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var WEEKDAY_NAMES = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+};
+var SECOND = { name: "second", min: 0, max: 59 };
+var MINUTE = { name: "minute", min: 0, max: 59 };
+var HOUR = { name: "hour", min: 0, max: 23 };
+var DAY_OF_MONTH = { name: "day-of-month", min: 1, max: 31 };
+var MONTH = { name: "month", min: 1, max: 12, names: MONTH_NAMES };
+var DAY_OF_WEEK = { name: "day-of-week", min: 0, max: 7, names: WEEKDAY_NAMES };
+var NICKNAMES = {
+  "@yearly": "0 0 1 1 *",
+  "@annually": "0 0 1 1 *",
+  "@monthly": "0 0 1 * *",
+  "@weekly": "0 0 * * 0",
+  "@daily": "0 0 * * *",
+  "@midnight": "0 0 * * *",
+  "@hourly": "0 * * * *"
+};
+var UNSUPPORTED_SYNTAX = /[LW#?]/i;
+var zoneFormatters = /* @__PURE__ */ new Map();
+function zoneFormatter(timeZone) {
+  const cached = zoneFormatters.get(timeZone);
+  if (cached) {
+    return cached;
+  }
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  zoneFormatters.set(timeZone, formatter);
+  return formatter;
+}
+function assertValidTimeZone(timeZone) {
+  try {
+    zoneFormatter(timeZone);
+  } catch {
+    throw new Error(`unknown timezone '${timeZone}'`);
+  }
+}
+function wallClockParts(date, timeZone) {
+  if (timeZone === void 0) {
+    return {
+      year: date.getFullYear(),
+      month: date.getMonth() + 1,
+      dayOfMonth: date.getDate(),
+      hour: date.getHours(),
+      minute: date.getMinutes(),
+      second: date.getSeconds(),
+      dayOfWeek: date.getDay()
+    };
+  }
+  const fields = {};
+  for (const part of zoneFormatter(timeZone).formatToParts(date)) {
+    if (part.type !== "literal") {
+      fields[part.type] = Number(part.value);
+    }
+  }
+  const year = fields.year ?? 0;
+  const month = fields.month ?? 1;
+  const dayOfMonth = fields.day ?? 1;
+  const hour = fields.hour === 24 ? 0 : fields.hour ?? 0;
+  return {
+    year,
+    month,
+    dayOfMonth,
+    hour,
+    minute: fields.minute ?? 0,
+    second: fields.second ?? 0,
+    dayOfWeek: new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay()
+  };
+}
+function resolveValue(token, spec) {
+  let value;
+  if (/^\d+$/.test(token)) {
+    value = Number(token);
+  } else if (spec.names) {
+    const named = spec.names[token.toLowerCase()];
+    if (named === void 0) {
+      throw new Error(`unknown name '${token}' in ${spec.name} field`);
+    }
+    value = named;
+  } else {
+    throw new Error(`invalid value '${token}' in ${spec.name} field`);
+  }
+  if (value < spec.min || value > spec.max) {
+    throw new Error(`value ${value} out of range ${spec.min}-${spec.max} in ${spec.name} field`);
+  }
+  return value;
+}
+function parseListItem(item, spec, out) {
+  const slashParts = item.split("/");
+  if (slashParts.length > 2) {
+    throw new Error(`invalid step syntax '${item}' in ${spec.name} field`);
+  }
+  const [base, stepToken] = slashParts;
+  let step = 1;
+  if (stepToken !== void 0) {
+    if (!/^\d+$/.test(stepToken)) {
+      throw new Error(`invalid step '${stepToken}' in ${spec.name} field`);
+    }
+    step = Number(stepToken);
+    if (step < 1) {
+      throw new Error(`step must be at least 1 in ${spec.name} field`);
+    }
+  }
+  let start;
+  let end;
+  if (base === "*") {
+    start = spec.min;
+    end = spec.max;
+  } else if (base.includes("-")) {
+    const rangeParts = base.split("-");
+    if (rangeParts.length !== 2) {
+      throw new Error(`invalid range '${base}' in ${spec.name} field`);
+    }
+    start = resolveValue(rangeParts[0], spec);
+    end = resolveValue(rangeParts[1], spec);
+  } else {
+    start = resolveValue(base, spec);
+    end = stepToken !== void 0 ? spec.max : start;
+  }
+  if (start > end) {
+    throw new Error(`range start ${start} is after end ${end} in ${spec.name} field`);
+  }
+  for (let value = start; value <= end; value += step) {
+    out.add(spec === DAY_OF_WEEK ? value % 7 : value);
+  }
+}
+function parseField(raw, spec) {
+  if (raw === "") {
+    throw new Error(`empty ${spec.name} field`);
+  }
+  if (UNSUPPORTED_SYNTAX.test(raw)) {
+    throw new Error(`unsupported syntax '${raw}' in ${spec.name} field`);
+  }
+  const values = /* @__PURE__ */ new Set();
+  for (const item of raw.split(",")) {
+    parseListItem(item, spec, values);
+  }
+  return values;
+}
+function isFullRange(values, spec) {
+  const span = spec === DAY_OF_WEEK ? 7 : spec.max - spec.min + 1;
+  return values.size >= span;
+}
+function expandNickname(expression) {
+  const expanded = NICKNAMES[expression.toLowerCase()];
+  if (expanded === void 0) {
+    throw new Error(`unsupported nickname '${expression}'`);
+  }
+  return expanded;
+}
+var ParsedCron = class {
+  constructor(hasSeconds, seconds, minutes, hours, daysOfMonth, months, daysOfWeek, domRestricted, dowRestricted) {
+    this.hasSeconds = hasSeconds;
+    this.seconds = seconds;
+    this.minutes = minutes;
+    this.hours = hours;
+    this.daysOfMonth = daysOfMonth;
+    this.months = months;
+    this.daysOfWeek = daysOfWeek;
+    this.domRestricted = domRestricted;
+    this.dowRestricted = dowRestricted;
+  }
+  matches(parts) {
+    if (this.hasSeconds && !this.seconds.has(parts.second)) {
+      return false;
+    }
+    if (!this.minutes.has(parts.minute)) {
+      return false;
+    }
+    if (!this.hours.has(parts.hour)) {
+      return false;
+    }
+    if (!this.months.has(parts.month)) {
+      return false;
+    }
+    const domMatch = this.daysOfMonth.has(parts.dayOfMonth);
+    const dowMatch = this.daysOfWeek.has(parts.dayOfWeek);
+    if (this.domRestricted && this.dowRestricted) {
+      return domMatch || dowMatch;
+    }
+    return domMatch && dowMatch;
+  }
+};
+function parseCron(expression) {
+  const trimmed = expression.trim();
+  if (trimmed === "") {
+    throw new Error("cron expression is empty");
+  }
+  const normalized = trimmed.startsWith("@") ? expandNickname(trimmed) : trimmed;
+  const fields = normalized.split(/\s+/);
+  let hasSeconds;
+  let secondRaw;
+  let minuteRaw;
+  let hourRaw;
+  let domRaw;
+  let monthRaw;
+  let dowRaw;
+  if (fields.length === 6) {
+    hasSeconds = true;
+    [secondRaw, minuteRaw, hourRaw, domRaw, monthRaw, dowRaw] = fields;
+  } else if (fields.length === 5) {
+    hasSeconds = false;
+    secondRaw = "0";
+    [minuteRaw, hourRaw, domRaw, monthRaw, dowRaw] = fields;
+  } else {
+    throw new Error(`expected 5 or 6 fields but got ${fields.length}`);
+  }
+  const daysOfMonth = parseField(domRaw, DAY_OF_MONTH);
+  const daysOfWeek = parseField(dowRaw, DAY_OF_WEEK);
+  return new ParsedCron(
+    hasSeconds,
+    parseField(secondRaw, SECOND),
+    parseField(minuteRaw, MINUTE),
+    parseField(hourRaw, HOUR),
+    daysOfMonth,
+    parseField(monthRaw, MONTH),
+    daysOfWeek,
+    !isFullRange(daysOfMonth, DAY_OF_MONTH),
+    !isFullRange(daysOfWeek, DAY_OF_WEEK)
+  );
+}
+
+// src/core/backup/scheduler.ts
+var DEFAULT_MAX_FILES = 5;
+var MINUTE_RESOLUTION_MS = 6e4;
+var SECOND_RESOLUTION_MS = 1e3;
+var DST_LOOKBACK_MS = 3 * 60 * 60 * 1e3;
+function toError(value) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return new BackupError(typeof value === "string" ? value : "Scheduled backup failed");
+}
+function slotKey(parts, hasSeconds) {
+  const base = `${parts.year}-${parts.month}-${parts.dayOfMonth}-${parts.hour}-${parts.minute}`;
+  return hasSeconds ? `${base}-${parts.second}` : base;
+}
+function zoneOffsetMs(date, timeZone) {
+  const parts = wallClockParts(date, timeZone);
+  const wallAsUtc = Date.UTC(parts.year, parts.month - 1, parts.dayOfMonth, parts.hour, parts.minute, parts.second);
+  return wallAsUtc - Math.floor(date.getTime() / 1e3) * 1e3;
+}
+function isRepeatedWallClock(now, nowParts, timeZone, hasSeconds) {
+  const offsetNow = zoneOffsetMs(now, timeZone);
+  const offsetBefore = zoneOffsetMs(new Date(now.getTime() - DST_LOOKBACK_MS), timeZone);
+  if (offsetNow >= offsetBefore) {
+    return false;
+  }
+  const shift = offsetBefore - offsetNow;
+  const firstOccurrence = wallClockParts(new Date(now.getTime() - shift), timeZone);
+  return slotKey(firstOccurrence, hasSeconds) === slotKey(nowParts, hasSeconds);
+}
+var INITIAL_TICK_STATE = {
+  lastFiredSlot: "",
+  lastFiredEpoch: Number.NEGATIVE_INFINITY
+};
+function evaluateTick(now, cron, timeZone, state) {
+  const nowEpoch = now.getTime();
+  if (nowEpoch <= state.lastFiredEpoch) {
+    return { shouldFire: false, nextState: state };
+  }
+  const parts = wallClockParts(now, timeZone);
+  if (!cron.matches(parts)) {
+    return { shouldFire: false, nextState: state };
+  }
+  const slot = slotKey(parts, cron.hasSeconds);
+  if (slot === state.lastFiredSlot) {
+    return { shouldFire: false, nextState: state };
+  }
+  if (isRepeatedWallClock(now, parts, timeZone, cron.hasSeconds)) {
+    return { shouldFire: false, nextState: state };
+  }
+  return { shouldFire: true, nextState: { lastFiredSlot: slot, lastFiredEpoch: nowEpoch } };
+}
+function runDirect(op) {
+  return op();
+}
+var BackupScheduler = class {
+  manager;
+  constructor(manager) {
+    this.manager = manager ?? new BackupManager();
+  }
+  schedule(conn, options, runExclusive = runDirect) {
+    const { cron: cronExpr, destDir, maxFiles = DEFAULT_MAX_FILES, onError, timezone } = options;
+    let cron;
+    try {
+      cron = parseCron(cronExpr);
+    } catch (err) {
+      throw new BackupError(
+        `Invalid cron expression '${cronExpr}': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (timezone !== void 0) {
+      try {
+        assertValidTimeZone(timezone);
+      } catch (err) {
+        throw new BackupError(`Invalid timezone '${timezone}': ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const resolvedDir = resolve(destDir);
+    if (!existsSync(resolvedDir)) {
+      try {
+        mkdirSync(resolvedDir, { recursive: true });
+      } catch (err) {
+        throw new BackupError(
+          `Failed to create backup directory '${destDir}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return this.run(conn, cron, resolvedDir, maxFiles, timezone, runExclusive, onError);
+  }
+  run(conn, cron, resolvedDir, maxFiles, timezone, runExclusive, onError) {
+    const tickMs = cron.hasSeconds ? SECOND_RESOLUTION_MS : MINUTE_RESOLUTION_MS;
+    let timer = null;
+    let stopped = false;
+    let running = false;
+    let tickState = INITIAL_TICK_STATE;
+    const runBackup = async () => {
+      try {
+        const destPath = join(resolvedDir, this.manager.generateFilename());
+        await runExclusive(() => this.manager.backup(conn, destPath));
+        this.manager.rotate(resolvedDir, maxFiles);
+      } catch (err) {
+        if (onError) {
+          try {
+            onError(toError(err));
+          } catch {
+          }
+        }
+      } finally {
+        running = false;
+      }
+    };
+    const scheduleNext = () => {
+      if (stopped) {
+        return;
+      }
+      const delay = tickMs - Date.now() % tickMs;
+      timer = setTimeout(onTick, delay);
+      timer.unref?.();
+    };
+    const onTick = () => {
+      if (stopped) {
+        return;
+      }
+      if (!running) {
+        const { shouldFire, nextState } = evaluateTick(/* @__PURE__ */ new Date(), cron, timezone, tickState);
+        if (shouldFire) {
+          tickState = nextState;
+          running = true;
+          void runBackup();
+        }
+      }
+      scheduleNext();
+    };
+    scheduleNext();
+    return () => {
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
+  }
+};
+
+export { BackupManager, BackupScheduler };

package/dist/{chunk-O7BHI3CF.mjs → chunk-YPYVQJ4C.mjs}

@@ -59,6 +59,12 @@ var CDCError = class extends SirannonError {
     this.name = "CDCError";
   }
 };
+var ForbiddenSqlError = class extends SirannonError {
+  constructor(message) {
+    super(message, "FORBIDDEN_SQL");
+    this.name = "ForbiddenSqlError";
+  }
+};
 var BackupError = class extends SirannonError {
   constructor(message) {
     super(message, "BACKUP_ERROR");
@@ -77,6 +83,14 @@ var MaxDatabasesError = class extends SirannonError {
     this.name = "MaxDatabasesError";
   }
 };
+var WriteOverloadError = class extends SirannonError {
+  constructor(limit, retryAfterMs) {
+    super(`Write rejected: ${limit} writes already pending`, "WRITE_OVERLOADED");
+    this.limit = limit;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "WriteOverloadError";
+  }
+};
 var ExtensionError = class extends SirannonError {
   constructor(path, cause) {
     super(
@@ -87,4 +101,4 @@ var ExtensionError = class extends SirannonError {
   }
 };
 
-export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError };
+export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, ForbiddenSqlError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError, WriteOverloadError };