@serve.zone/gitops 32.1.0 → 32.2.0

package/ts/db/classes.gitops-db.ts

@@ -0,0 +1,92 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logging.js';
+
+export interface IGitopsDbOptions {
+  /** Connection URL of the document database gitops persists into. */
+  mongoDbUrl: string;
+  /** Database name inside that server. */
+  mongoDbName: string;
+}
+
+const requireEnv = (keyArg: string): string => {
+  const value = process.env[keyArg];
+  if (!value) {
+    throw new Error(`GitOps requires ${keyArg} to be set and non-empty.`);
+  }
+  if (value.trim() !== value) {
+    throw new Error(`GitOps requires ${keyArg} to be canonical without surrounding whitespace.`);
+  }
+  return value;
+};
+
+/**
+ * Reads the database binding from the process environment. There is no default and no
+ * embedded fallback: gitops keeps every durable record — connections, jobs, sync
+ * configuration, managed secrets, the action log and the provider caches — in this one
+ * database, so a missing binding has to stop startup rather than silently produce an
+ * instance that forgets everything it was told.
+ */
+export const readGitopsDbOptionsFromEnvironment = (): IGitopsDbOptions => ({
+  mongoDbUrl: requireEnv('GITOPS_MONGODB_URL'),
+  // An explicitly set but empty name is a misconfiguration, not a request for the default.
+  mongoDbName: process.env.GITOPS_MONGODB_NAME === undefined ? 'gitops' : requireEnv('GITOPS_MONGODB_NAME'),
+});
+
+/**
+ * The single document database behind gitops.
+ *
+ * Every model binds its collection through `GitopsDb.getInstance().getDb()`, so the
+ * singleton is the only place that knows the connection. Tests construct it with an
+ * explicit binding to an isolated server; the application reads the binding from the
+ * environment.
+ */
+export class GitopsDb {
+  private static instance: GitopsDb | null = null;
+
+  private smartdataDb: plugins.smartdata.SmartdataDb | null = null;
+  private readonly options: IGitopsDbOptions;
+
+  private constructor(options: IGitopsDbOptions) {
+    this.options = options;
+  }
+
+  static getInstance(options?: IGitopsDbOptions): GitopsDb {
+    if (!GitopsDb.instance) {
+      if (!options) {
+        throw new Error('GitopsDb has no instance yet — the first call must supply its options.');
+      }
+      GitopsDb.instance = new GitopsDb(options);
+    }
+    return GitopsDb.instance;
+  }
+
+  static resetInstance(): void {
+    GitopsDb.instance = null;
+  }
+
+  async start(): Promise<void> {
+    logger.info('Connecting to the gitops database...');
+    const smartdataDb = new plugins.smartdata.SmartdataDb({
+      mongoDbUrl: this.options.mongoDbUrl,
+      mongoDbName: this.options.mongoDbName,
+    });
+    await smartdataDb.init();
+    this.smartdataDb = smartdataDb;
+    logger.success(`Connected to the gitops database (db: ${this.options.mongoDbName})`);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.smartdataDb) return;
+    const smartdataDb = this.smartdataDb;
+    this.smartdataDb = null;
+    await smartdataDb.close();
+    logger.success('Disconnected from the gitops database');
+  }
+
+  getDb(): plugins.smartdata.SmartdataDb {
+    if (!this.smartdataDb) {
+      throw new Error('GitopsDb not started. Call start() first.');
+    }
+    return this.smartdataDb;
+  }
+}

package/ts/{cache → db}/documents/classes.cached.project.ts

@@ -1,11 +1,11 @@
 import * as plugins from '../../plugins.js';
-import { CacheDb } from '../classes.cachedb.js';
+import { GitopsDb } from '../classes.gitops-db.js';
 import { CachedDocument, TTL } from '../classes.cached.document.js';
 
 /**
  * Cached project data from git providers. TTL: 5 minutes.
  */
-@plugins.smartdata.Collection(() => CacheDb.getInstance().getDb())
+@plugins.smartdata.Collection(() => GitopsDb.getInstance().getDb())
 export class CachedProject extends CachedDocument<CachedProject> {
   @plugins.smartdata.unI()
   public id: string = '';

package/ts/{cache → db}/documents/classes.cached.secret.ts

@@ -1,12 +1,12 @@
 import * as plugins from '../../plugins.js';
-import { CacheDb } from '../classes.cachedb.js';
+import { GitopsDb } from '../classes.gitops-db.js';
 import { CachedDocument, TTL } from '../classes.cached.document.js';
 import type { ISecret } from '../../../ts_interfaces/data/secret.js';
 
 /**
  * Cached secret data from git providers. TTL: 24 hours.
  */
-@plugins.smartdata.Collection(() => CacheDb.getInstance().getDb())
+@plugins.smartdata.Collection(() => GitopsDb.getInstance().getDb())
 export class CachedSecret extends CachedDocument<CachedSecret> {
   @plugins.smartdata.unI()
   public id: string = '';

package/ts/db/documents/classes.storage.record.ts

@@ -0,0 +1,26 @@
+import * as plugins from '../../plugins.js';
+import { GitopsDb } from '../classes.gitops-db.js';
+
+const getDb = () => GitopsDb.getInstance().getDb();
+
+/**
+ * One durable key/value record.
+ *
+ * `key` owns the stored `_id`, so the primary key is the single uniqueness authority: a
+ * write is one identity-anchored upsert with no second index to disagree with, and a
+ * prefix listing is answered by the `_id` index instead of a collection scan. That is what
+ * `identityAsDocumentId: 'key'` declares, and it holds for every record this collection
+ * ever received, because the store below has always derived `_id` from the key.
+ */
+@plugins.smartdata.Collection(() => getDb(), { identityAsDocumentId: 'key' })
+export class StorageRecord extends plugins.smartdata.SmartDataDbDoc<
+  StorageRecord,
+  StorageRecord
+> {
+  @plugins.smartdata.unI()
+  @plugins.smartdata.svDb()
+  public key!: string;
+
+  @plugins.smartdata.svDb()
+  public value!: string;
+}

package/ts/{cache → db}/documents/index.ts

@@ -1,2 +1,3 @@
 export { CachedProject } from './classes.cached.project.js';
 export { CachedSecret } from './classes.cached.secret.js';
+export { StorageRecord } from './classes.storage.record.js';

package/ts/db/index.ts

@@ -0,0 +1,5 @@
+export { GitopsDb, readGitopsDbOptionsFromEnvironment } from './classes.gitops-db.js';
+export type { IGitopsDbOptions } from './classes.gitops-db.js';
+export { CachedDocument, TTL } from './classes.cached.document.js';
+export { CacheCleaner } from './classes.cache.cleaner.js';
+export * from './documents/index.js';

package/ts/paths.ts

@@ -2,8 +2,8 @@ import * as plugins from './plugins.js';
 
 export interface IGitopsPaths {
   gitopsHomeDir: string;
-  defaultStoragePath: string;
-  defaultTsmDbPath: string;
+  /** Directory the releases before the document database wrote key/value records into. */
+  legacyStoragePath: string;
 }
 
 /**
@@ -13,7 +13,6 @@ export function resolvePaths(baseDir?: string): IGitopsPaths {
   const home = baseDir ?? plugins.path.join(process.env.HOME ?? '/tmp', '.serve.zone', 'gitops');
   return {
     gitopsHomeDir: home,
-    defaultStoragePath: plugins.path.join(home, 'storage'),
-    defaultTsmDbPath: plugins.path.join(home, 'tsmdb'),
+    legacyStoragePath: plugins.path.join(home, 'storage'),
   };
 }

package/ts/plugins.ts

@@ -30,9 +30,11 @@ import * as bookstackClient from '@apiclient.xyz/bookstack';
 export { giteaClient, gitlabClient, bookstackClient };
 
 // Database
-import * as smartmongo from '@push.rocks/smartmongo';
-import * as smartdata from '@push.rocks/smartdata';
-export { smartmongo, smartdata };
+// The document ORM. Exported as `smartdata` because that is the name every call site uses and
+// because `@lossless.org/client/nosqldb` supersedes `@push.rocks/smartdata` with an identical
+// API surface; the persisted shape is unchanged.
+import * as smartdata from '@lossless.org/client/nosqldb';
+export { smartdata };
 
 // Secrets
 import * as smartsecret from '@push.rocks/smartsecret';

package/ts/storage/classes.storagemanager.ts

@@ -1,31 +1,27 @@
-import * as plugins from '../plugins.js';
+import { StorageRecord } from '../db/documents/classes.storage.record.js';
 
-export type TStorageBackend = 'filesystem' | 'memory';
-
-export interface IStorageConfig {
-  backend?: TStorageBackend;
-  fsPath?: string;
-}
+/**
+ * The upper bound of the key range scanned for a prefix listing. `￿` is above every
+ * character a normalized key may contain, so `[prefix/, prefix/￿)` covers the whole
+ * subtree of a prefix and nothing beyond it.
+ */
+const KEY_RANGE_END = '￿';
 
-const isNotFoundError = (error: unknown): boolean => {
-  return error instanceof Error && (error as NodeJS.ErrnoException).code === 'ENOENT';
-};
+/**
+ * The key is the record's primary key, and MongoDB indexes a primary key of at most
+ * 1024 bytes; the bound is stated here so an oversized key is refused by name instead of
+ * surfacing as a driver index error on write.
+ */
+const MAX_KEY_BYTES = 1024;
 
 /**
- * Key-value storage abstraction with filesystem and memory backends.
- * Keys must start with '/' and are normalized (no '..', no double slashes).
+ * Key-value storage for gitops' durable records, kept in the `StorageRecord` collection.
+ *
+ * Keys must start with '/' and are normalized (no '..', no double slashes). Listing is
+ * non-recursive: it returns the direct children of a prefix, which is what every caller
+ * relies on to keep neighbouring key spaces apart.
  */
 export class StorageManager {
-  private backend: TStorageBackend;
-  private fsPath: string;
-  private memoryStore: Map<string, string>;
-
-  constructor(config: IStorageConfig = {}) {
-    this.backend = config.backend ?? 'filesystem';
-    this.fsPath = config.fsPath ?? './storage';
-    this.memoryStore = new Map();
-  }
-
   /**
    * Normalize and validate a storage key.
    */
@@ -35,101 +31,69 @@ export class StorageManager {
     }
     // Strip '..' segments and normalize double slashes
     const segments = key.split('/').filter((s) => s !== '' && s !== '..');
-    return '/' + segments.join('/');
-  }
-
-  /**
-   * Resolve a key to a filesystem path.
-   */
-  private keyToPath(key: string): string {
-    const normalized = this.normalizeKey(key);
-    return plugins.path.join(this.fsPath, ...normalized.split('/').filter(Boolean));
+    const normalized = '/' + segments.join('/');
+    if (Buffer.byteLength(normalized, 'utf8') > MAX_KEY_BYTES) {
+      throw new Error(`Storage key exceeds ${MAX_KEY_BYTES} bytes: ${normalized.slice(0, 64)}…`);
+    }
+    return normalized;
   }
 
   async get(key: string): Promise<string | null> {
-    const normalized = this.normalizeKey(key);
-    if (this.backend === 'memory') {
-      return this.memoryStore.get(normalized) ?? null;
-    }
-    try {
-      return await plugins.fs.readFile(this.keyToPath(normalized), 'utf8');
-    } catch (err) {
-      if (isNotFoundError(err)) return null;
-      throw err;
-    }
+    const record = await StorageRecord.getInstance<StorageRecord>({
+      key: this.normalizeKey(key),
+    });
+    return record ? record.value : null;
   }
 
   async set(key: string, value: string): Promise<void> {
-    const normalized = this.normalizeKey(key);
-    if (this.backend === 'memory') {
-      this.memoryStore.set(normalized, value);
-      return;
-    }
-    const filePath = this.keyToPath(normalized);
-    const dir = plugins.path.dirname(filePath);
-    await plugins.fs.mkdir(dir, { recursive: true });
-    // Atomic write: write to temp then rename
-    const tmpPath = filePath + '.tmp';
-    await plugins.fs.writeFile(tmpPath, value, 'utf8');
-    await plugins.fs.rename(tmpPath, filePath);
+    // The equality anchor on `key` is what makes this a single race-free upsert: the
+    // primary key is derived from the filter, and the client seeds the immutable identity
+    // from that same anchor, so the key is never restated in the update document.
+    await StorageRecord.atomicUpdate<StorageRecord>(
+      { key: this.normalizeKey(key) },
+      { $set: { value } },
+      { upsert: true },
+    );
   }
 
   async delete(key: string): Promise<boolean> {
     const normalized = this.normalizeKey(key);
-    if (this.backend === 'memory') {
-      return this.memoryStore.delete(normalized);
-    }
-    try {
-      await plugins.fs.rm(this.keyToPath(normalized));
-      return true;
-    } catch (err) {
-      if (isNotFoundError(err)) return false;
-      throw err;
+    if (!(await StorageRecord.exists<StorageRecord>({ key: normalized }))) {
+      return false;
     }
+    // The identity pins a single document, which is what a singular delete requires.
+    await StorageRecord.atomicDelete<StorageRecord>({ key: normalized });
+    return true;
   }
 
   async exists(key: string): Promise<boolean> {
-    const normalized = this.normalizeKey(key);
-    if (this.backend === 'memory') {
-      return this.memoryStore.has(normalized);
-    }
-    try {
-      await plugins.fs.stat(this.keyToPath(normalized));
-      return true;
-    } catch (err) {
-      if (isNotFoundError(err)) return false;
-      throw err;
-    }
+    return StorageRecord.exists<StorageRecord>({ key: this.normalizeKey(key) });
   }
 
   /**
-   * List keys under a given prefix.
+   * List the keys directly below a given prefix. Records deeper in the subtree are read by
+   * the range scan and then dropped, mirroring the directory listing this replaced.
    */
   async list(prefix: string): Promise<string[]> {
     const normalized = this.normalizeKey(prefix);
-    if (this.backend === 'memory') {
-      const keys: string[] = [];
-      for (const key of this.memoryStore.keys()) {
-        if (key.startsWith(normalized)) {
-          keys.push(key);
-        }
-      }
-      return keys.sort();
-    }
-    const dirPath = this.keyToPath(normalized);
-    const keys: string[] = [];
+    // Normalization leaves the root as '/', which is already its own child prefix.
+    const childPrefix = normalized.endsWith('/') ? normalized : `${normalized}/`;
+    const cursor = await StorageRecord.getCursor<StorageRecord>(
+      { key: { $gte: childPrefix, $lt: `${childPrefix}${KEY_RANGE_END}` } },
+      // Only the keys are wanted here; leaving the values in the database keeps a listing
+      // independent of how much each record holds.
+      { projection: { key: 1 } },
+    );
+    let records: StorageRecord[];
     try {
-      const entries = await plugins.fs.readdir(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isFile()) {
-          keys.push(normalized.replace(/\/$/, '') + '/' + entry.name);
-        }
-      }
-    } catch (err) {
-      if (isNotFoundError(err)) return [];
-      throw err;
+      records = await cursor.toArray();
+    } finally {
+      await cursor.close();
     }
-    return keys.sort();
+    return records
+      .map((recordArg) => recordArg.key)
+      .filter((keyArg) => !keyArg.slice(childPrefix.length).includes('/'))
+      .sort();
   }
 
   async getJSON<T>(key: string): Promise<T | null> {

package/ts/storage/index.ts

@@ -1,2 +1 @@
 export { StorageManager } from './classes.storagemanager.js';
-export type { IStorageConfig, TStorageBackend } from './classes.storagemanager.js';

package/ts_migrations/classes.migration-record.ts

@@ -0,0 +1,23 @@
+import * as plugins from '../ts/plugins.js';
+import { GitopsDb } from '../ts/db/index.js';
+
+/**
+ * The ledger of migrations that have run to completion.
+ *
+ * `migration` owns the stored `_id`, so a migration is looked up by primary key and can
+ * only ever be recorded once.
+ */
+@plugins.smartdata.Collection(() => GitopsDb.getInstance().getDb(), {
+  identityAsDocumentId: 'migration',
+})
+export class MigrationRecord extends plugins.smartdata.SmartDataDbDoc<
+  MigrationRecord,
+  MigrationRecord
+> {
+  @plugins.smartdata.unI()
+  @plugins.smartdata.svDb()
+  public migration!: string;
+
+  @plugins.smartdata.svDb()
+  public completedAt!: number;
+}

package/ts_migrations/import-filesystem-records.ts

@@ -0,0 +1,79 @@
+import * as plugins from '../ts/plugins.js';
+import type { IMigration, IMigrationContext } from './interfaces.js';
+
+interface ILegacyConnection {
+  id: string;
+}
+
+/**
+ * Reads every regular file below `directoryArg` and yields it as a storage key relative to
+ * the tree root, so `<root>/connections/a.json` becomes `/connections/a.json`.
+ */
+const readDirectoryEntries = async (directoryArg: string) => {
+  try {
+    return await plugins.fs.readdir(directoryArg, { withFileTypes: true });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+};
+
+const readLegacyTree = async (
+  directoryArg: string,
+  prefixArg: string,
+): Promise<{ key: string; value: string }[]> => {
+  const entries = await readDirectoryEntries(directoryArg);
+  const records: { key: string; value: string }[] = [];
+  for (const entry of entries) {
+    const entryPath = plugins.path.join(directoryArg, entry.name);
+    if (entry.isDirectory()) {
+      records.push(...(await readLegacyTree(entryPath, `${prefixArg}/${entry.name}`)));
+    } else if (entry.isFile()) {
+      records.push({
+        key: `${prefixArg}/${entry.name}`,
+        value: await plugins.fs.readFile(entryPath, 'utf8'),
+      });
+    }
+  }
+  return records;
+};
+
+/**
+ * Imports the key/value records that earlier releases kept as files.
+ *
+ * Both sources are read once and never written back: the ledger, not a renamed file, is
+ * what records that this ran. The legacy tree is left on disk untouched so an operator can
+ * archive it after confirming the import.
+ */
+export const importFilesystemRecords: IMigration = {
+  name: 'import-filesystem-records',
+  run: async (contextArg: IMigrationContext): Promise<void> => {
+    // The development-time connections file was the authority over the tree before, and
+    // stays it here: it is written first and the tree import below skips existing keys.
+    try {
+      const legacyText = await plugins.fs.readFile(contextArg.legacyConnectionsFile, 'utf8');
+      const legacyConnections = JSON.parse(legacyText) as ILegacyConnection[];
+      for (const connection of legacyConnections) {
+        await contextArg.storage.setJSON(`/connections/${connection.id}.json`, connection);
+      }
+      if (legacyConnections.length > 0) {
+        contextArg.log(`imported ${legacyConnections.length} connection(s) from the legacy file`);
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+
+    const records = await readLegacyTree(contextArg.legacyStoragePath, '');
+    let imported = 0;
+    for (const record of records) {
+      // A key that already exists was written by a newer authority — the legacy file above
+      // or a release that already ran against the database — so it is never overwritten.
+      if (await contextArg.storage.exists(record.key)) continue;
+      await contextArg.storage.set(record.key, record.value);
+      imported++;
+    }
+    if (imported > 0) {
+      contextArg.log(`imported ${imported} record(s) from ${contextArg.legacyStoragePath}`);
+    }
+  },
+};

package/ts_migrations/index.ts

@@ -0,0 +1,31 @@
+import { MigrationRecord } from './classes.migration-record.js';
+import { importFilesystemRecords } from './import-filesystem-records.js';
+import type { IMigration, IMigrationContext } from './interfaces.js';
+
+export type { IMigration, IMigrationContext } from './interfaces.js';
+export { MigrationRecord } from './classes.migration-record.js';
+
+/** Applied in order; a name that is already in the ledger is skipped. */
+const migrations: readonly IMigration[] = [importFilesystemRecords];
+
+/**
+ * Runs the pending migrations against an already connected database.
+ *
+ * Called from startup only, after the database is up and before any manager reads a
+ * record. No lease is taken: every migration is idempotent, so two instances starting at
+ * the same time converge on the same result, while a lease would let one crashed claimant
+ * block every later start.
+ */
+export const runStartupMigrations = async (contextArg: IMigrationContext): Promise<void> => {
+  for (const migration of migrations) {
+    if (await MigrationRecord.exists<MigrationRecord>({ migration: migration.name })) continue;
+    contextArg.log(`running migration ${migration.name}`);
+    await migration.run(contextArg);
+    await MigrationRecord.atomicUpdate<MigrationRecord>(
+      { migration: migration.name },
+      { $set: { completedAt: Date.now() } },
+      { upsert: true },
+    );
+    contextArg.log(`migration ${migration.name} completed`);
+  }
+};

package/ts_migrations/interfaces.ts

@@ -0,0 +1,18 @@
+import type { StorageManager } from '../ts/storage/index.js';
+
+export interface IMigrationContext {
+  /** The document-backed key/value store every migration writes through. */
+  storage: StorageManager;
+  /** Root of the key/value tree the releases before the document database wrote. */
+  legacyStoragePath: string;
+  /** The development-time connection list earlier releases imported on every start. */
+  legacyConnectionsFile: string;
+  /** Reports progress to the application log. */
+  log: (messageArg: string) => void;
+}
+
+export interface IMigration {
+  /** Stable identity recorded in the ledger once the migration completed. */
+  name: string;
+  run: (contextArg: IMigrationContext) => Promise<void>;
+}

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/gitops',
-  version: '32.1.0',
+  version: '32.2.0',
   description: 'GitOps management app for Gitea and GitLab - manage secrets, browse projects, view CI pipelines, and stream build logs'
 }

package/dist_ts/cache/classes.cache.cleaner.js

@@ -1,61 +0,0 @@
-import { logger } from '../logging.js';
-import { unrefTimer } from '../timers.js';
-const DEFAULT_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
-/**
- * Periodically cleans up expired cached documents.
- */
-export class CacheCleaner {
-    intervalId = null;
-    intervalMs;
-    documentClasses = [];
-    cacheDb;
-    constructor(cacheDb, intervalMs = DEFAULT_INTERVAL_MS) {
-        this.cacheDb = cacheDb;
-        this.intervalMs = intervalMs;
-    }
-    /** Register a document class for cleanup */
-    registerClass(cls) {
-        this.documentClasses.push(cls);
-    }
-    start() {
-        if (this.intervalId !== null)
-            return;
-        this.intervalId = setInterval(() => {
-            this.clean().catch((err) => {
-                logger.error(`CacheCleaner error: ${err}`);
-            });
-        }, this.intervalMs);
-        // Unref so the interval doesn't prevent process exit
-        unrefTimer(this.intervalId);
-        logger.debug(`CacheCleaner started (interval: ${this.intervalMs}ms)`);
-    }
-    stop() {
-        if (this.intervalId !== null) {
-            clearInterval(this.intervalId);
-            this.intervalId = null;
-            logger.debug('CacheCleaner stopped');
-        }
-    }
-    /** Run a single cleanup pass */
-    async clean() {
-        const now = Date.now();
-        let totalDeleted = 0;
-        for (const cls of this.documentClasses) {
-            try {
-                const expired = await cls.getInstances({ expiresAt: { $lt: now } });
-                for (const doc of expired) {
-                    await doc.delete();
-                    totalDeleted++;
-                }
-            }
-            catch (err) {
-                logger.error(`CacheCleaner: failed to clean class: ${err}`);
-            }
-        }
-        if (totalDeleted > 0) {
-            logger.debug(`CacheCleaner: deleted ${totalDeleted} expired document(s)`);
-        }
-        return totalDeleted;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jYWNoZS5jbGVhbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvY2FjaGUvY2xhc3Nlcy5jYWNoZS5jbGVhbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQU0xQyxNQUFNLG1CQUFtQixHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUMsU0FBUztBQUVyRDs7R0FFRztBQUNILE1BQU0sT0FBTyxZQUFZO0lBQ2YsVUFBVSxHQUEwQyxJQUFJLENBQUM7SUFDekQsVUFBVSxDQUFTO0lBQ25CLGVBQWUsR0FBb0IsRUFBRSxDQUFDO0lBQ3RDLE9BQU8sQ0FBVTtJQUV6QixZQUFZLE9BQWdCLEVBQUUsVUFBVSxHQUFHLG1CQUFtQjtRQUM1RCxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztJQUMvQixDQUFDO0lBRUQsNENBQTRDO0lBQzVDLGFBQWEsQ0FBQyxHQUFrQjtRQUM5QixJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQsS0FBSztRQUNILElBQUksSUFBSSxDQUFDLFVBQVUsS0FBSyxJQUFJO1lBQUUsT0FBTztRQUNyQyxJQUFJLENBQUMsVUFBVSxHQUFHLFdBQVcsQ0FBQyxHQUFHLEVBQUU7WUFDakMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO2dCQUN6QixNQUFNLENBQUMsS0FBSyxDQUFDLHVCQUF1QixHQUFHLEVBQUUsQ0FBQyxDQUFDO1lBQzdDLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNwQixxREFBcUQ7UUFDckQsVUFBVSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUM1QixNQUFNLENBQUMsS0FBSyxDQUFDLG1DQUFtQyxJQUFJLENBQUMsVUFBVSxLQUFLLENBQUMsQ0FBQztJQUN4RSxDQUFDO0lBRUQsSUFBSTtRQUNGLElBQUksSUFBSSxDQUFDLFVBQVUsS0FBSyxJQUFJLEVBQUUsQ0FBQztZQUM3QixhQUFhLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQy9CLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO1lBQ3ZCLE1BQU0sQ0FBQyxLQUFLLENBQUMsc0JBQXNCLENBQUMsQ0FBQztRQUN2QyxDQUFDO0lBQ0gsQ0FBQztJQUVELGdDQUFnQztJQUNoQyxLQUFLLENBQUMsS0FBSztRQUNULE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUN2QixJQUFJLFlBQVksR0FBRyxDQUFDLENBQUM7UUFDckIsS0FBSyxNQUFNLEdBQUcsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDdkMsSUFBSSxDQUFDO2dCQUNILE1BQU0sT0FBTyxHQUFHLE1BQU0sR0FBRyxDQUFDLFlBQVksQ0FBQyxFQUFFLFNBQVMsRUFBRSxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7Z0JBQ3BFLEtBQUssTUFBTSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7b0JBQzFCLE1BQU0sR0FBRyxDQUFDLE1BQU0sRUFBRSxDQUFDO29CQUNuQixZQUFZLEVBQUUsQ0FBQztnQkFDakIsQ0FBQztZQUNILENBQUM7WUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO2dCQUNiLE1BQU0sQ0FBQyxLQUFLLENBQUMsd0NBQXdDLEdBQUcsRUFBRSxDQUFDLENBQUM7WUFDOUQsQ0FBQztRQUNILENBQUM7UUFDRCxJQUFJLFlBQVksR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNyQixNQUFNLENBQUMsS0FBSyxDQUFDLHlCQUF5QixZQUFZLHNCQUFzQixDQUFDLENBQUM7UUFDNUUsQ0FBQztRQUNELE9BQU8sWUFBWSxDQUFDO0lBQ3RCLENBQUM7Q0FDRiJ9

package/dist_ts/cache/classes.cachedb.d.ts

@@ -1,22 +0,0 @@
-import * as plugins from '../plugins.js';
-export interface ICacheDbOptions {
-    storagePath?: string;
-    dbName?: string;
-    debug?: boolean;
-}
-/**
- * Singleton wrapper around SmartMongo's NoSQLDB memory server and SmartData.
- * Provides a managed MongoDB-compatible cache database.
- */
-export declare class CacheDb {
-    private static instance;
-    private smartMongo;
-    private smartdataDb;
-    private options;
-    private constructor();
-    static getInstance(options?: ICacheDbOptions): CacheDb;
-    static resetInstance(): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getDb(): InstanceType<typeof plugins.smartdata.SmartdataDb>;
-}