LokiJS

const loki = require('lokijs');

import loki from 'lokijs';

<script src="lokijs.js"></script>
<!-- loki is available as a global variable -->

const loki = require('lokijs');

// Create database
const db = new loki('example.db');

// Add collection
const users = db.addCollection('users');

// Insert documents
users.insert({ name: 'Alice', age: 25, active: true });
users.insert({ name: 'Bob', age: 30, active: false });
users.insert({ name: 'Charlie', age: 35, active: true });

// Query documents
const activeUsers = users.find({ active: true });
const user = users.findOne({ name: 'Alice' });

// Chain operations
const result = users.chain()
  .find({ active: true })
  .where(obj => obj.age > 25)
  .simplesort('name')
  .data();

// Save database (with adapter)
db.saveDatabase();

class Loki {
  constructor(filename?: string, options?: DatabaseOptions);
  
  addCollection(name: string, options?: CollectionOptions): Collection;
  getCollection(collectionName: string): Collection | null;
  removeCollection(collectionName: string): void;
  
  loadDatabase(options?: any, callback?: Function): void;
  saveDatabase(callback?: Function): void;
  serialize(options?: SerializeOptions): string;
}

class Collection {
  constructor(name: string, options?: CollectionOptions);
  
  insert(doc: object | object[]): object | object[];
  update(doc: object): object;
  remove(doc: object): object;
  find(query?: object): object[];
  findOne(query?: object): object | null;
  
  chain(transform?: string, parameters?: object): Resultset;
  where(fun: Function): object[];
  count(query?: object): number;
}

class Resultset {
  constructor(collection: Collection, options?: object);
  
  find(query: object, firstOnly?: boolean): Resultset;
  where(fun: Function): Resultset;
  sort(comparefun: Function): Resultset;
  simplesort(propname: string, options?: object): Resultset;
  limit(qty: number): Resultset;
  offset(pos: number): Resultset;
  data(options?: object): object[];
}

class DynamicView {
  constructor(collection: Collection, name: string, options?: object);
  
  applyFind(query: object): DynamicView;
  applyWhere(fun: Function): DynamicView;
  applySort(comparefun: Function): DynamicView;
  applySimpleSort(propname: string, options?: object): DynamicView;
  
  data(options?: object): object[];
  count(): number;
  rematerialize(): DynamicView;
}

interface PersistenceAdapter {
  loadDatabase(dbname: string, callback: Function): void;
  saveDatabase(dbname: string, dbref: object, callback: Function): void;
}

// Built-in adapters
class LokiFsAdapter implements PersistenceAdapter;
class LokiLocalStorageAdapter implements PersistenceAdapter;
class LokiMemoryAdapter implements PersistenceAdapter;
class LokiPartitioningAdapter implements PersistenceAdapter;

class KeyValueStore {
  constructor();
  
  /** Set a key-value pair */
  set(key: any, value: any): void;
  
  /** Get values for a key */
  get(key: any): any[];
  
  /** Set custom sort function */
  setSort(fun: Function): void;
  
  /** Remove a key-value pair */
  remove(key: any, value: any): void;
  
  /** Clear all key-value pairs */
  clear(): void;
}

// Object utilities
loki.deepFreeze(obj: object): void;
loki.freeze(obj: object): void;
loki.unFreeze(obj: object): object;

// Comparison helpers
loki.aeq(prop1: any, prop2: any): boolean;
loki.lt(prop1: any, prop2: any, equal?: boolean): boolean;
loki.gt(prop1: any, prop2: any, equal?: boolean): boolean;

// Query operations (complete set)
loki.LokiOps: {
  // Comparison operators
  $eq: Function, $aeq: Function, $ne: Function, $dteq: Function,
  $gt: Function, $gte: Function, $lt: Function, $lte: Function,
  $jgt: Function, $jgte: Function, $jlt: Function, $jlte: Function,
  
  // Range operators
  $between: Function, $jbetween: Function,
  
  // Array/Set operators
  $in: Function, $nin: Function, $inSet: Function,
  $contains: Function, $containsAny: Function, $containsNone: Function,
  $containsString: Function,
  
  // Object operators
  $keyin: Function, $nkeyin: Function, $definedin: Function, $undefinedin: Function,
  $elemMatch: Function,
  
  // Pattern matching
  $regex: Function, $type: Function, $where: Function
};

// Comparator functions
loki.Comparators: {
  aeq: Function,
  lt: Function, 
  gt: Function
};

// Constructors available on loki
loki.Collection: typeof Collection;
loki.DynamicView: typeof DynamicView;
loki.Resultset: typeof Resultset;
loki.KeyValueStore: typeof KeyValueStore;

// Persistence adapters
loki.LokiMemoryAdapter: typeof LokiMemoryAdapter;
loki.LokiPartitioningAdapter: typeof LokiPartitioningAdapter;
loki.LokiLocalStorageAdapter: typeof LokiLocalStorageAdapter;
loki.LokiFsAdapter: typeof LokiFsAdapter;
loki.persistenceAdapters: {
  fs: typeof LokiFsAdapter;
  localStorage: typeof LokiLocalStorageAdapter;
};

// Event system (inherited by Loki, Collection, DynamicView)
interface EventEmitter {
  on(eventName: string, listener: Function): void;
  emit(eventName: string, ...args: any[]): void;
  removeListener(eventName: string, listener: Function): void;
}

interface DatabaseOptions {
  autosave?: boolean;
  autosaveInterval?: number;
  adapter?: PersistenceAdapter;
  serializationMethod?: string;
  destructureDelimiter?: string;
  verbose?: boolean;
  throttledSaves?: boolean;
  env?: string;
  persistenceMethod?: string;
}

interface CollectionOptions {
  unique?: string[];
  exact?: string[];
  indices?: string[];
  adaptiveBinaryIndices?: boolean;
  asyncListeners?: boolean;
  disableMeta?: boolean;
  disableChangesApi?: boolean;
  disableDeltaChangesApi?: boolean;
  autoupdate?: boolean;
  clone?: boolean;
  cloneMethod?: string;
  transactional?: boolean;
  ttl?: number;
  ttlInterval?: number;
  serializableIndices?: boolean;
}

interface SerializeOptions {
  serializationMethod?: string;
  destructureDelimiter?: string;
}