@delali/sirannon-db 0.1.3 → 0.1.5

package/dist/file-migrations/index.mjs

@@ -0,0 +1,128 @@
+import { MigrationError } from '../chunk-O7BHI3CF.mjs';
+import { statSync, readdirSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+
+var MIGRATION_FILENAME_PATTERN = /^(\d+)_(\w+)\.(up|down)\.sql$/;
+function hasControlCharacters(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) <= 31) return true;
+  }
+  return false;
+}
+function scanDirectory(dirPath) {
+  if (hasControlCharacters(dirPath)) {
+    throw new MigrationError("Migration path contains invalid characters", 0, "MIGRATION_VALIDATION_ERROR");
+  }
+  const segments = dirPath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new MigrationError(
+      "Migration path must not contain directory traversal segments",
+      0,
+      "MIGRATION_VALIDATION_ERROR"
+    );
+  }
+  const resolvedPath = resolve(dirPath);
+  let stat;
+  try {
+    stat = statSync(resolvedPath);
+  } catch {
+    throw new MigrationError(`Migrations path does not exist: ${resolvedPath}`, 0);
+  }
+  if (!stat.isDirectory()) {
+    throw new MigrationError(`Migrations path is not a directory: ${resolvedPath}`, 0);
+  }
+  const entries = readdirSync(resolvedPath, { withFileTypes: true });
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const match = MIGRATION_FILENAME_PATTERN.exec(entry.name);
+    if (!match) continue;
+    const version = parseInt(match[1], 10);
+    const name = match[2];
+    const direction = match[3];
+    if (!Number.isFinite(version) || version <= 0 || !Number.isSafeInteger(version)) {
+      throw new MigrationError(`Invalid migration version: ${match[1]}`, version, "MIGRATION_VALIDATION_ERROR");
+    }
+    const existing = grouped.get(version);
+    if (existing && existing.name !== name) {
+      throw new MigrationError(
+        `Duplicate migration version ${version}: '${existing.name}' and '${name}'`,
+        version,
+        "MIGRATION_DUPLICATE_VERSION"
+      );
+    }
+    const filePath = join(resolvedPath, entry.name);
+    if (!existing) {
+      grouped.set(version, {
+        name,
+        [direction === "up" ? "upPath" : "downPath"]: filePath
+      });
+    } else {
+      if (direction === "up") existing.upPath = filePath;
+      else existing.downPath = filePath;
+    }
+  }
+  const results = [];
+  for (const [version, entry] of grouped) {
+    if (!entry.upPath) {
+      throw new MigrationError(
+        `Migration version ${version} (${entry.name}) is missing an .up.sql file`,
+        version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    results.push({
+      version,
+      name: entry.name,
+      upPath: entry.upPath,
+      downPath: entry.downPath ?? null
+    });
+  }
+  results.sort((a, b) => a.version - b.version);
+  return results;
+}
+function readUpMigrations(scanned) {
+  return scanned.map((entry) => {
+    const sql = readFileSync(entry.upPath, "utf-8").trim();
+    if (sql.length === 0) {
+      throw new MigrationError(`Migration file is empty: ${entry.upPath}`, entry.version, "MIGRATION_VALIDATION_ERROR");
+    }
+    return {
+      version: entry.version,
+      name: entry.name,
+      up: sql
+    };
+  });
+}
+function readDownMigrations(scanned, versions) {
+  const versionSet = new Set(versions);
+  const filtered = scanned.filter((s) => versionSet.has(s.version));
+  return filtered.map((entry) => {
+    if (!entry.downPath) {
+      throw new MigrationError(
+        `Migration version ${entry.version} (${entry.name}) has no .down.sql file`,
+        entry.version,
+        "MIGRATION_NO_DOWN"
+      );
+    }
+    const downSql = readFileSync(entry.downPath, "utf-8").trim();
+    if (downSql.length === 0) {
+      throw new MigrationError(
+        `Down migration file is empty: ${entry.downPath}`,
+        entry.version,
+        "MIGRATION_VALIDATION_ERROR"
+      );
+    }
+    return {
+      version: entry.version,
+      name: entry.name,
+      up: "",
+      down: downSql
+    };
+  });
+}
+function loadMigrations(dirPath) {
+  return readUpMigrations(scanDirectory(dirPath));
+}
+
+export { loadMigrations, readDownMigrations, readUpMigrations, scanDirectory };

package/dist/index-CLdNrcPz.d.ts

@@ -0,0 +1,16 @@
+import { a as SQLiteConnection } from './types-BFSsG77t.js';
+import { m as BackupScheduleOptions } from './types-D-74JiXb.js';
+
+declare class BackupManager {
+    backup(conn: SQLiteConnection, destPath: string): Promise<void>;
+    generateFilename(): string;
+    rotate(dir: string, maxFiles: number): void;
+}
+
+declare class BackupScheduler {
+    private readonly manager;
+    constructor(manager?: BackupManager);
+    schedule(conn: SQLiteConnection, options: BackupScheduleOptions): () => void;
+}
+
+export { BackupManager as B, BackupScheduler as a };

package/dist/replication/coordinator/etcd.d.ts

@@ -0,0 +1,44 @@
+import { IOptions } from 'etcd3';
+import { C as ClusterCoordinator, A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, R as RegisterNodeSessionInput, b as CoordinatorNodeSession, S as SetReplicationGroupStateInput, c as ReplicationGroupState, d as ReplicationGroupWatcher, e as CoordinatorWatchDisposer, f as CompareAndAdvancePrimaryTermInput, g as CompareAndAdvancePrimaryTermResult, U as UpdateInSyncSetInput, h as AdmitNodeToInSyncSetInput, i as UpdateNodeMaintenanceInput, P as PromoteEligibleReplicaInput } from '../../types-BEu1I_9_.js';
+
+interface EtcdClusterCoordinatorOptions {
+    hosts: string | string[];
+    keyPrefix: string;
+    credentials?: IOptions['credentials'];
+    auth?: IOptions['auth'];
+    grpcOptions?: IOptions['grpcOptions'];
+    dialTimeoutMs?: number;
+    defaultCallTimeoutMs?: number;
+    allowInsecure?: boolean;
+    onWatcherError?: (error: Error) => void;
+}
+declare class EtcdClusterCoordinator implements ClusterCoordinator {
+    private readonly client;
+    private readonly namespace;
+    private readonly onWatcherError;
+    private readonly leases;
+    private readonly watchers;
+    constructor(options: EtcdClusterCoordinatorOptions);
+    tryAcquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    renewLease(leaseId: string, ttlMs: number): Promise<boolean>;
+    releaseLease(leaseId: string): Promise<boolean>;
+    registerNodeSession(input: RegisterNodeSessionInput): Promise<CoordinatorNodeSession>;
+    getLiveNodeSession(clusterId: string, nodeId: string): Promise<CoordinatorNodeSession | null>;
+    deregisterNodeSession(clusterId: string, nodeId: string): Promise<void>;
+    setReplicationGroupState(input: SetReplicationGroupStateInput): Promise<ReplicationGroupState>;
+    getReplicationGroupState(clusterId: string, groupId: string): Promise<ReplicationGroupState | null>;
+    watchReplicationGroup(clusterId: string, groupId: string, watcher: ReplicationGroupWatcher): Promise<CoordinatorWatchDisposer>;
+    compareAndAdvancePrimaryTerm(input: CompareAndAdvancePrimaryTermInput): Promise<CompareAndAdvancePrimaryTermResult>;
+    updateInSyncSet(input: UpdateInSyncSetInput): Promise<ReplicationGroupState | null>;
+    admitNodeToInSyncSet(input: AdmitNodeToInSyncSetInput): Promise<ReplicationGroupState | null>;
+    updateNodeMaintenance(input: UpdateNodeMaintenanceInput): Promise<ReplicationGroupState | null>;
+    promoteEligibleReplica(input: PromoteEligibleReplicaInput): Promise<ReplicationGroupState>;
+    close(): Promise<void>;
+    private getLeaseFromKey;
+    private trackLease;
+    private updateGroupStateWithRetry;
+    private casGroupState;
+}
+declare function createEtcdCoordinator(options: EtcdClusterCoordinatorOptions): EtcdClusterCoordinator;
+
+export { EtcdClusterCoordinator, type EtcdClusterCoordinatorOptions, createEtcdCoordinator };