datahike 0.8.1872 → 0.8.1877

package/remote.d.ts

@@ -0,0 +1,709 @@
+// Auto-generated TypeScript definitions for Datahike JavaScript API
+// DO NOT EDIT - Generated from datahike.api.specification
+
+
+// Core Datahike Types
+
+export type Keyword = `:${string}`;
+export type Attribute = Keyword;
+
+declare const datahikeUuidBrand: unique symbol;
+/** Opaque UUID input returned by uuid() and randomUuid(). */
+export interface DatahikeUuid {
+  readonly [datahikeUuidBrand]: true;
+}
+/** UUID values returned by the JavaScript boundary are ordinary strings. */
+export type UuidValue = string;
+
+/** A named branch (for example `':db'` or `':feature'`). */
+export type BranchName = Keyword;
+/** A branch name or an input UUID created with uuid(). */
+export type VersionRef = BranchName | DatahikeUuid;
+
+export interface GcOptions {
+  /** Keep objects written within this many milliseconds, even if unreachable. */
+  'min-age-ms'?: number;
+}
+
+export interface StoreConfig {
+  backend: Keyword;
+  id?: DatahikeUuid;
+  path?: string;
+  [key: string]: any;
+}
+
+/** S3 backend configuration for the opt-in `datahike/s3` browser entry. */
+export interface S3StoreConfig extends StoreConfig {
+  backend: ':s3';
+  id: DatahikeUuid;
+  endpoint: string;
+  bucket: string;
+  'access-key': string;
+  secret: string;
+  region?: string;
+  'session-token'?: string;
+  'path-style?'?: boolean;
+  config?: {
+    'optimistic-locking-retries'?: number;
+    [key: string]: any;
+  };
+}
+
+/**
+ * Browser-safe Datahike storage: a complete synchronous memory frontend over
+ * an asynchronous, authoritative S3 backend. Bare S3StoreConfig is not a
+ * usable Datahike query store in browsers.
+ */
+export interface TieredS3StoreConfig extends StoreConfig {
+  backend: ':tiered';
+  id: DatahikeUuid;
+  'frontend-config': { backend: ':memory'; id: DatahikeUuid };
+  'backend-config': S3StoreConfig;
+  'write-policy'?: ':write-through';
+  'read-policy'?: ':frontend-first';
+}
+
+export interface WriterConfig {
+  backend: Keyword;
+  [key: string]: any;
+}
+
+export interface ConnectOptions {
+  /**
+   * Preserve the ClojureScript API's execution mode. Memory stores can run
+   * synchronously; browser and remote stores use false and resolve a Promise.
+   */
+  'sync?'?: boolean;
+  [key: string]: any;
+}
+
+/** Persistent browser backend registered by the `datahike/kabel` entry. */
+export interface IndexedDbStoreConfig extends StoreConfig {
+  backend: ':indexeddb';
+  id: DatahikeUuid;
+  name?: string;
+}
+
+/** Synchronous memory frontend over an authoritative IndexedDB cache. */
+export interface TieredIndexedDbStoreConfig extends StoreConfig {
+  backend: ':tiered';
+  id: DatahikeUuid;
+  'frontend-config': { backend: ':memory'; id: DatahikeUuid };
+  'backend-config': IndexedDbStoreConfig;
+  'write-policy'?: ':write-through';
+  'read-policy'?: ':frontend-first';
+}
+
+export interface DatabaseConfig {
+  store: StoreConfig;
+  writer?: WriterConfig;
+  branch?: Keyword;
+  'keep-history?'?: boolean;
+  'schema-flexibility'?: ':read' | ':write';
+  'initial-tx'?: Transaction[];
+  name?: string;
+  [key: string]: any;
+}
+
+declare const connectionBrand: unique symbol;
+export interface Connection {
+  readonly [connectionBrand]: true;
+}
+
+declare const databaseBrand: unique symbol;
+export interface Database {
+  readonly [databaseBrand]: true;
+}
+
+export type EntityId = number | string | [Attribute, any];
+export type EntityMap = Record<string, any>;
+export type Transaction =
+  | [':db/add', EntityId, Attribute, any]
+  | [':db/retract', EntityId, Attribute, any]
+  | [Keyword, ...any[]]
+  | EntityMap;
+
+export interface WithArgs {
+  'tx-data': Transaction[];
+  'tx-meta'?: any;
+}
+
+export interface QueryArgs {
+  query: string | any[] | Record<string, any>;
+  args?: any[];
+  limit?: number;
+  offset?: number;
+}
+
+export interface PullOptions {
+  selector: any[];
+  eid: EntityId | EntityId[];
+}
+
+export type Index = ':eavt' | ':aevt' | ':avet';
+export interface IndexLookupArgs {
+  index: Index;
+  components?: any[] | null;
+}
+
+export interface IndexRangeArgs {
+  attrid: Attribute;
+  start: any;
+  end: any;
+}
+
+export interface TransactionReport {
+  'db-before': Database;
+  'db-after': Database;
+  'tx-data': Datom[];
+  tempids: { [key: string]: number };
+  'tx-meta'?: any;
+}
+
+export interface DurableCommitEvent {
+  type: ':datahike/commit';
+  'store-id': UuidValue;
+  branch: Keyword;
+  'commit-id': UuidValue;
+  'parent-commit-ids': UuidValue[];
+  'max-tx': number;
+  'tx-count': number;
+  'db-before': Database;
+  'db-after': Database;
+  'tx-reports': TransactionReport[];
+}
+
+export interface Datom {
+  e: number;
+  a: Attribute;
+  v: any;
+  tx: number;
+  added: boolean;
+}
+
+export interface Schema {
+  [key: string]: {
+    'db/valueType': Keyword;
+    'db/cardinality': Keyword;
+    'db/unique'?: Keyword;
+    'db/index'?: boolean;
+    [key: string]: any;
+  };
+}
+
+export interface Metrics {
+  count: number;
+  'avet-count': number;
+  'per-attr-counts': Record<string, number>;
+  'per-entity-counts'?: Record<string, number>;
+  'temporal-count'?: number;
+  'temporal-avet-count'?: number;
+}
+
+export interface OptimisticOverlay {
+  readonly __optimisticOverlayBrand: never;
+}
+
+export interface OptimisticOptions {
+  'max-pending'?: number;
+  'max-queue'?: number;
+  'prediction-timeout-ms'?: number | null;
+  'reconciliation-timeout-ms'?: number | null;
+}
+
+export interface OptimisticSubmitOptions {
+  branch?: Keyword;
+}
+
+export interface OptimisticPredictionOptions extends OptimisticSubmitOptions {
+  'timeout-ms'?: number | null;
+}
+
+export type OptimisticTransactionInput =
+  | Transaction[]
+  | { 'tx-data': Transaction[]; 'tx-meta'?: any };
+
+export type OptimisticResultStatus =
+  | ':committed'
+  | ':accepted'
+  | ':reconciled'
+  | ':rejected'
+  | ':expired'
+  | ':abandoned'
+  | ':unknown'
+  | ':detached';
+
+export interface OptimisticResult {
+  status: OptimisticResultStatus;
+  error?: any;
+  receipt?: any;
+  'tx-report'?: TransactionReport;
+  outcome?: ':unknown' | ':committed';
+  reason?: any;
+  'accepted?'?: boolean;
+}
+
+export interface OptimisticHandle {
+  ovId: string;
+  result: Promise<OptimisticResult>;
+}
+
+export interface OptimisticPendingEntry {
+  'ov-id': string;
+  kind: ':writer' | ':prediction';
+  'submitted-at': number;
+  'expires-at'?: number | null;
+  'expected-max-tx'?: number | null;
+  branch?: string;
+  'acknowledged?': boolean;
+  'conflicting?': boolean;
+  'last-conflict-error'?: any;
+  'reconcile-deadline-at'?: number | null;
+  'reconciliation-stalled?'?: boolean;
+  [key: string]: any;
+}
+
+export interface OptimisticChanges {
+  added: Datom[];
+  removed: Datom[];
+}
+
+export interface OptimisticTransition {
+  revision: number;
+  'db-before': Database;
+  'db-after': Database;
+  'base-max-tx': number | null;
+  cause: { type: string; [key: string]: any };
+  changes: OptimisticChanges | null;
+}
+
+export interface OptimisticStatusEvent {
+  revision: number;
+  'ov-id': string;
+  kind: ':writer' | ':prediction';
+  status:
+    | ':visible'
+    | ':acknowledged'
+    | ':committed'
+    | ':reconciled'
+    | ':rejected'
+    | ':expired'
+    | ':abandoned'
+    | ':conflicting'
+    | ':applicable'
+    | ':reconciliation-error'
+    | ':reconciliation-stalled'
+    | ':unknown'
+    | ':detached';
+  [key: string]: any;
+}
+
+
+// API Functions (the thin HTTP client; every call reaches the server)
+
+/**
+ * Returns database state at given time point (Date or transaction ID)..
+ *
+ * Examples:
+ * - Query as of date
+ *   (q '[:find ?n :where [_ :name ?n]] (as-of @conn date))
+ * - Query as of transaction
+ *   (as-of @conn 536870913)
+ */
+export function asOf(arg0: Database, arg1: number | Date): Promise<Database>;
+
+/**
+ * Create a new branch from an existing branch or commit.
+ *
+ * Examples:
+ * - Branch from main
+ *   (branch! conn :db :experiment)
+ * - Branch from specific commit
+ *   (branch! conn #uuid "..." :hotfix)
+ */
+export function branch(conn: Connection, from: VersionRef, newBranch: Keyword): Promise<unknown>;
+
+/**
+ * Load the database at a branch head.
+ *
+ * Examples:
+ * - Load db at branch
+ *   (branch-as-db conn :experiment)
+ */
+export function branchAsDb(source: Connection | Database, branch: Keyword): Promise<Database | null>;
+
+/**
+ * List all known branch names.
+ *
+ * Examples:
+ * - List branches
+ *   (branches conn)
+ */
+export function branches(conn: Connection): Promise<Array<Keyword>>;
+
+/**
+ * Load the database at a specific commit.
+ *
+ * Examples:
+ * - Load db at commit
+ *   (commit-as-db conn #uuid "...")
+ */
+export function commitAsDb(source: Connection | Database, commit: DatahikeUuid): Promise<Database | null>;
+
+/**
+ * Retrieve the commit-id for this database value..
+ *
+ * Examples:
+ * - Get commit id
+ *   (commit-id @conn)
+ */
+export function commitId(db: Database): Promise<UuidValue | null>;
+
+/**
+ * Connects to a Datahike database via configuration map..
+ *
+ * Examples:
+ * - Connect to default in-memory database
+ *   (connect)
+ * - Connect to file-based database
+ *   (connect {:store {:backend :file :path "/tmp/example"}})
+ */
+export function connect(config: DatabaseConfig): Promise<Connection>;
+export function connect(config: DatabaseConfig, opts: ConnectOptions): Promise<Connection>;
+export function connect(): Promise<Connection>;
+
+/**
+ * Creates a database via configuration map..
+ *
+ * Examples:
+ * - Create empty database
+ *   (create-database {:store {:backend :memory :id "example"}})
+ * - Create with schema-flexibility :read
+ *   (create-database {:store {:backend :memory :id "example"} :schema-flexibility :read})
+ */
+export function createDatabase(arg0: DatabaseConfig): Promise<DatabaseConfig>;
+export function createDatabase(): Promise<DatabaseConfig>;
+
+/**
+ * Checks if a database exists via configuration map..
+ *
+ * Examples:
+ * - Check if in-memory database exists
+ *   (database-exists? {:store {:backend :memory :id "example"}})
+ * - Check with default config
+ *   (database-exists?)
+ */
+export function databaseExists(arg0: DatabaseConfig): Promise<boolean>;
+export function databaseExists(): Promise<boolean>;
+
+/**
+ * Index lookup.
+ *
+ * Examples:
+ * - Find all datoms for entity
+ *   (datoms db {:index :eavt :components [1]})
+ * - Find datoms for entity and attribute
+ *   (datoms db {:index :eavt :components [1 :likes]})
+ */
+export function datoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | IndexLookupArgs): Promise<Datom[] | null>;
+export function datoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<Datom[] | null>;
+
+/**
+ * Returns the underlying immutable database value from a connection.
+ *
+ * Examples:
+ * - Get database from connection
+ *   (db conn)
+ * - Prefer direct deref
+ *   @conn
+ */
+export function db(conn: Connection): Promise<Database>;
+
+/**
+ * Remove a branch.
+ *
+ * Examples:
+ * - Delete branch
+ *   (delete-branch! conn :experiment)
+ */
+export function deleteBranch(conn: Connection, branch: Keyword): Promise<unknown>;
+
+/**
+ * Deletes a database given via configuration map..
+ *
+ * Examples:
+ * - Delete database
+ *   (delete-database {:store {:backend :memory :id "example"}})
+ */
+export function deleteDatabase(arg0: DatabaseConfig): Promise<any>;
+export function deleteDatabase(): Promise<any>;
+
+/**
+ * Retrieves an entity by its id.
+ *
+ * Examples:
+ * - Get entity by id
+ *   (entity db 1)
+ * - Get entity by lookup ref
+ *   (entity db [:email "alice@example.com"])
+ */
+export function entity(db: Database, eid: number | [string, any] | string | any): Promise<any>;
+
+/**
+ * Returns database that entity was created from..
+ *
+ * Examples:
+ * - Get entity's database
+ *   (entity-db (entity db 1))
+ */
+export function entityDb(arg0: any): Promise<Database>;
+
+/**
+ * Invokes garbage collection on connection's store.
+ *
+ * Examples:
+ * - GC all old snapshots
+ *   (gc-storage conn)
+ * - GC snapshots before date
+ *   (gc-storage conn (java.util.Date.))
+ */
+export function gcStorage(conn: Connection, removeBefore: number | Date, options: GcOptions): Promise<unknown[]>;
+export function gcStorage(conn: Connection, removeBefore: number | Date): Promise<unknown[]>;
+export function gcStorage(conn: Connection): Promise<unknown[]>;
+
+/**
+ * Returns full historical state of database including all assertions and retractions..
+ *
+ * Examples:
+ * - Query historical data
+ *   (q '[:find ?n ?a :where [?e :name ?n] [?e :age ?a]] (history @conn))
+ */
+export function history(arg0: Database): Promise<Database>;
+
+/**
+ * Returns part of :avet index between start and end values..
+ *
+ * Examples:
+ * - Find datoms in value range
+ *   (index-range db {:attrid :likes :start "a" :end "z"})
+ * - Find entities with age in range
+ *   (->> (index-range db {:attrid :age :start 18 :end 60}) (map :e))
+ */
+export function indexRange(db: Database, options: IndexRangeArgs): Promise<Datom[]>;
+
+/**
+ * Load entities directly (bulk load)..
+ *
+ * Examples:
+ * - Bulk load entities
+ *   (load-entities conn entities)
+ */
+export function loadEntities(arg0: Connection, arg1: Transaction[]): Promise<any>;
+
+/**
+ * Create a merge commit combining the current branch with parent branches/commits.
+ *
+ * Examples:
+ * - Merge feature into main
+ *   (d/merge-db conn #{:feature} [{:name "merged entity"}])
+ * - Merge with metadata
+ *   (d/merge-db conn #{:feature} [{:name "merged"}] {:source :merge})
+ */
+export function mergeDb(arg0: Connection, arg1: Array<any>, arg2: Transaction[]): Promise<TransactionReport>;
+export function mergeDb(arg0: Connection, arg1: Array<any>, arg2: Transaction[], arg3: any): Promise<TransactionReport>;
+
+/**
+ * Returns database metrics: datom counts overall, per attribute and for the indexed (AVET) attributes, plus the same for history when kept.
+ *
+ * Examples:
+ * - Get metrics
+ *   (metrics @conn)
+ * - With datoms per entity (a full walk)
+ *   (metrics @conn {:per-entity-counts? true})
+ */
+export function metrics(arg0: Database): Promise<Metrics>;
+export function metrics(arg0: Database, arg1: Record<string, any>): Promise<Metrics>;
+
+/**
+ * Retrieve parent commit ids from this database value..
+ *
+ * Examples:
+ * - Get parent commits
+ *   (parent-commit-ids @conn)
+ */
+export function parentCommitIds(db: Database): Promise<UuidValue[] | null>;
+
+/**
+ * Fetches data using recursive declarative pull pattern..
+ *
+ * Examples:
+ * - Pull with pattern
+ *   (pull db [:db/id :name :likes {:friends [:db/id :name]}] 1)
+ * - Pull with arg-map
+ *   (pull db {:selector [:db/id :name] :eid 1})
+ */
+export function pull<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: PullOptions): Promise<T | null>;
+export function pull<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: Array<any>, eid: number | [string, any] | string): Promise<T | null>;
+
+/**
+ * Same as pull, but accepts sequence of ids and returns sequence of maps..
+ *
+ * Examples:
+ * - Pull multiple entities
+ *   (pull-many db [:db/id :name] [1 2 3])
+ */
+export function pullMany<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: PullOptions): Promise<T[]>;
+export function pullMany<T extends Record<string, any> = Record<string, any>>(db: Database, patternOrOptions: Array<any>, eids: Array<number | [string, any] | string>): Promise<T[]>;
+
+/**
+ * Executes a datalog query..
+ *
+ * Examples:
+ * - Query with vector syntax
+ *   (q '[:find ?value :where [_ :likes ?value]] db)
+ * - Query with map syntax
+ *   (q '{:find [?value] :where [[_ :likes ?value]]} db)
+ */
+export function q<T = unknown>(query: QueryArgs): Promise<T>;
+export function q<T = unknown>(query: Array<any> | Record<string, any> | string, ...inputs: Array<any>): Promise<T>;
+
+/**
+ * Executes query and returns execution statistics..
+ *
+ * Examples:
+ * - Query with stats
+ *   (query-stats '[:find ?e :where [?e :name]] db)
+ */
+export function queryStats(query: QueryArgs): Promise<Record<string, any>>;
+export function queryStats(query: Array<any> | Record<string, any>, ...inputs: Array<any>): Promise<Record<string, any>>;
+
+/**
+ * Releases a database connection..
+ *
+ * Examples:
+ * - Release connection
+ *   (release conn)
+ */
+export function release(conn: Connection): Promise<null>;
+export function release(conn: Connection, releaseAll: any): Promise<null>;
+
+/**
+ * Returns reverse schema definition (attribute id to ident mapping)..
+ *
+ * Examples:
+ * - Get reverse schema
+ *   (reverse-schema @conn)
+ */
+export function reverseSchema(arg0: Database): Promise<Record<string, any>>;
+
+/**
+ * Like seek-datoms, but iterates BACKWARDS: datoms <= the given components, descending to the beginning of the index.
+ *
+ * Examples:
+ * - Latest room messages, newest first
+ *   (take 20 (rseek-datoms db {:index :avet :components [:message/room room-eid]}))
+ */
+export function rseekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | IndexLookupArgs): Promise<Datom[] | null>;
+export function rseekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<Datom[] | null>;
+
+/**
+ * Returns current schema definition..
+ *
+ * Examples:
+ * - Get schema
+ *   (schema @conn)
+ */
+export function schema(arg0: Database): Promise<Schema>;
+
+/**
+ * Like datoms, but returns datoms starting from specified components through end of index..
+ *
+ * Examples:
+ * - Seek from entity
+ *   (seek-datoms db {:index :eavt :components [1]})
+ */
+export function seekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet" | IndexLookupArgs): Promise<Datom[] | null>;
+export function seekDatoms(db: Database, indexOrOptions: ":eavt" | ":aevt" | ":avet", ...components: Array<any>): Promise<Datom[] | null>;
+
+/**
+ * Returns database state since given time point (Date or transaction ID).
+ *
+ * Examples:
+ * - Query since date
+ *   (since @conn (java.util.Date.))
+ * - Query since transaction
+ *   (since @conn 536870913)
+ */
+export function since(arg0: Database, arg1: number | Date): Promise<Database>;
+
+/**
+ * Applies transaction to the database and updates connection.
+ *
+ * Examples:
+ * - Add single datom
+ *   (transact conn [[:db/add 1 :name "Ivan"]])
+ * - Retract datom
+ *   (transact conn [[:db/retract 1 :name "Ivan"]])
+ */
+export function transact(arg0: Connection, arg1: Transaction[] | WithArgs): Promise<TransactionReport>;
+
+/**
+ * Strip any valid-time markers from `db` so the full vt-history is
+           visible.
+ *
+ * Examples:
+ * - Drop vt-marker for full-history query
+ *   (q '[:find ?n :where [_ :name ?n]] (valid-all @conn))
+ */
+export function validAll(arg0: Database): Promise<Database>;
+
+/**
+ * Tag `db` with a `:datahike/valid-at` marker so vt-aware secondary
+           indices push the filter through `-search-at-vt`.
+ *
+ * Examples:
+ * - Query as of valid-time
+ *   (q '[:find ?n :where [_ :name ?n]] (valid-at @conn #inst "2024-04-15"))
+ */
+export function validAt(arg0: Database, arg1: any): Promise<Database>;
+
+/**
+ * Filter `db` to datoms whose asserting tx's vt-window overlaps the
+           half-open interval `[from, to)`.
+ *
+ * Examples:
+ * - Datoms whose tx vt-window overlaps Q2 2024
+ *   (q '[:find ?n :where [_ :name ?n]] (valid-between @conn #inst "2024-04-01" #inst "2024-07-01"))
+ */
+export function validBetween(arg0: Database, arg1: any, arg2: any): Promise<Database>;
+
+/**
+ * Filter `db` to datoms whose tx's vt-window is *fully contained*
+           in `[from, to)`.
+ *
+ * Examples:
+ * - Corrections whose vt-window was wholly inside Q2
+ *   (q '[:find ?e :where [?e :name _]] (valid-during @conn #inst "2024-04-01" #inst "2024-07-01"))
+ */
+export function validDuring(arg0: Database, arg1: any, arg2: any): Promise<Database>;
+
+export interface RemoteReport {
+  'db-after'?: Database;
+  'db-before'?: null;
+  'tx-data'?: Datom[];
+  tempids?: { [key: string]: number };
+  'commit-id'?: UuidValue;
+  resync?: boolean;
+  deleted?: boolean;
+  truncated?: boolean;
+  error?: any;
+  status?: number;
+}
+
+export function listen(conn: Connection, callback: (report: RemoteReport) => void): string;
+export function unlisten(conn: Connection, key: string): void;
+
+// JavaScript-specific value helpers.
+export function isPromise(value: any): value is Promise<unknown>;
+export function uuid(value: string): DatahikeUuid;
+export function randomUuid(): DatahikeUuid;

package/replikativ.logging.js

@@ -1,2 +1,2 @@
 var window=global;var $CLJS=require("./cljs_env.js");require("./cljs.core.js");require("./taoensso.trove.js");
-'use strict';$CLJS.yp=new $CLJS.H(null,"ref","ref",1289896967);$CLJS.zp=new $CLJS.H(null,"conn","conn",278309663);$CLJS.Ap=new $CLJS.H(null,"warn","warn",-436710552);
+'use strict';$CLJS.Cp=new $CLJS.H(null,"ref","ref",1289896967);$CLJS.Dp=new $CLJS.H(null,"conn","conn",278309663);$CLJS.Ep=new $CLJS.H(null,"warn","warn",-436710552);$CLJS.Fp=new $CLJS.H(null,"eavt","eavt",-666437073);