@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/protocol-6KrSq2Hy.d.ts

@@ -0,0 +1,66 @@
+import { W as WriteConcern, R as ReadConcern, E as ExecuteResult } from './types-zhnRXrsb.js';
+import { B as BulkLoadDurability, a as BulkLoadResult } from './server-options-1JHu8pid.js';
+
+interface QueryRequest {
+    sql: string;
+    params?: Record<string, unknown> | unknown[];
+    readConcern?: ReadConcern;
+}
+interface ExecuteRequest {
+    sql: string;
+    params?: Record<string, unknown> | unknown[];
+    writeConcern?: WriteConcern;
+}
+interface TransactionStatement {
+    sql: string;
+    params?: Record<string, unknown> | unknown[];
+}
+interface TransactionRequest {
+    statements: TransactionStatement[];
+    writeConcern?: WriteConcern;
+}
+/** The whole batch commits atomically in one server-side transaction with one fsync. */
+interface BatchRequest {
+    sql: string;
+    paramsBatch: (Record<string, unknown> | unknown[])[];
+    writeConcern?: WriteConcern;
+}
+interface QueryResponse {
+    rows: Record<string, unknown>[];
+}
+interface ExecuteResponse {
+    changes: number;
+    lastInsertRowId: number | string;
+}
+interface TransactionResponse {
+    results: ExecuteResponse[];
+}
+interface BatchResponse {
+    results: ExecuteResponse[];
+}
+/**
+ * Loads rows with relaxed writer durability; the configured durability is
+ * restored before the response is sent, and a load interrupted by a crash is
+ * recovered by re-running it.
+ */
+interface LoadRequest {
+    sql: string;
+    paramsBatch: (Record<string, unknown> | unknown[])[];
+    durability?: BulkLoadDurability;
+    checkpoint?: boolean;
+}
+type LoadResponse = BulkLoadResult;
+interface AckResponse {
+    acked: boolean;
+    seq: string;
+}
+interface ErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+declare function toExecuteResponse(result: ExecuteResult): ExecuteResponse;
+
+export { type AckResponse as A, type BatchResponse as B, type ExecuteResponse as E, type LoadResponse as L, type QueryResponse as Q, type TransactionStatement as T, type TransactionResponse as a, type BatchRequest as b, type ErrorResponse as c, type ExecuteRequest as d, type LoadRequest as e, type QueryRequest as f, type TransactionRequest as g, toExecuteResponse as t };

package/dist/react/index.d.ts

@@ -0,0 +1,20 @@
+import { L as LiveQueryOptions, a as LiveQuery, b as LiveQueryState } from '../types-CL6piSnD.js';
+import { O as OperationRef } from '../operation-registry-9DcvxcE5.js';
+import { P as Params } from '../types-zhnRXrsb.js';
+
+interface LiveDatabase {
+    live(operation: string | OperationRef<never, never>, args?: never, options?: LiveQueryOptions): Promise<LiveQuery<unknown>>;
+}
+interface UseLiveQueryOptions extends LiveQueryOptions {
+    enabled?: boolean;
+}
+declare function useLiveQuery<Row = Record<string, unknown>>(database: LiveDatabase, operation: string, args?: Params, options?: UseLiveQueryOptions): LiveQueryState<Row>;
+declare function useLiveQuery<Args, Row>(database: LiveDatabase, operation: OperationRef<Args, Row>, args: Args, options?: UseLiveQueryOptions): LiveQueryState<Row>;
+declare function useCommand<Args, Result>(database: {
+    execute(operation: OperationRef<Args, unknown>, args: Args): Promise<Result>;
+}, command: OperationRef<Args, unknown>): (args: Args) => Promise<Result>;
+declare function useCommand<Result>(database: {
+    execute(sql: string, params?: Params): Promise<Result>;
+}, command: string): (params?: Params) => Promise<Result>;
+
+export { type LiveDatabase, LiveQueryState, type UseLiveQueryOptions, useCommand, useLiveQuery };

package/dist/react/index.mjs

@@ -0,0 +1,137 @@
+import { useMemo, useSyncExternalStore, useCallback, useRef } from 'react';
+
+// src/react/index.ts
+
+// src/core/operation-registry.ts
+function operationRef(name) {
+  return { name };
+}
+
+// src/react/live-query-store.ts
+var PENDING = { status: "pending" };
+function createLiveQueryStore(open) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = PENDING;
+  let query = null;
+  let detach = null;
+  let generation = 0;
+  function publish(next) {
+    if (next === snapshot) return;
+    snapshot = next;
+    for (const listener of [...listeners]) listener();
+  }
+  function start() {
+    if (open === null) return;
+    const opened = generation;
+    open().then(
+      (next) => {
+        if (opened !== generation) {
+          void next.close().catch(discard);
+          return;
+        }
+        query = next;
+        detach = next.subscribe(() => publish(next.getState()));
+        publish(next.getState());
+      },
+      (reason) => {
+        if (opened !== generation) return;
+        publish({ status: "error", error: reason instanceof Error ? reason : new Error(String(reason)) });
+      }
+    );
+  }
+  function stop() {
+    generation++;
+    detach?.();
+    detach = null;
+    const closing = query;
+    query = null;
+    snapshot = PENDING;
+    void closing?.close().catch(discard);
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      if (listeners.size === 1) start();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) stop();
+      };
+    },
+    getSnapshot() {
+      return snapshot;
+    }
+  };
+}
+function getServerSnapshot() {
+  return PENDING;
+}
+function discard() {
+}
+function useStableValue(value) {
+  const held = useRef(value);
+  if (held.current !== value && !sameValue(held.current, value)) held.current = value;
+  return held.current;
+}
+function sameValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) return sameArray(left, right);
+  if (ArrayBuffer.isView(left) || ArrayBuffer.isView(right)) return sameBytes(left, right);
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+  }
+  return sameRecord(left, right);
+}
+function sameArray(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index++) {
+    if (!sameValue(left[index], right[index])) return false;
+  }
+  return true;
+}
+function sameBytes(left, right) {
+  if (!(left instanceof Uint8Array) || !(right instanceof Uint8Array) || left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index++) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+function sameRecord(left, right) {
+  const keys = Object.keys(left);
+  if (keys.length !== Object.keys(right).length) return false;
+  for (const key of keys) {
+    if (!Object.hasOwn(right, key)) return false;
+    if (!sameValue(left[key], right[key])) return false;
+  }
+  return true;
+}
+
+// src/react/index.ts
+function useLiveQuery(database, operation, args, options) {
+  const literal = typeof operation === "string";
+  const name = literal ? operation : operation.name;
+  const enabled = options?.enabled !== false;
+  const rereadJitterMs = options?.rereadJitterMs;
+  const maxTransactionChanges = options?.maxTransactionChanges;
+  const stableArgs = useStableValue(args);
+  const store = useMemo(() => {
+    if (!enabled) return createLiveQueryStore(null);
+    const target = literal ? name : operationRef(name);
+    const queryOptions = {
+      ...rereadJitterMs === void 0 ? {} : { rereadJitterMs },
+      ...maxTransactionChanges === void 0 ? {} : { maxTransactionChanges }
+    };
+    return createLiveQueryStore(
+      () => database.live(target, stableArgs, queryOptions)
+    );
+  }, [database, literal, name, stableArgs, enabled, rereadJitterMs, maxTransactionChanges]);
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, getServerSnapshot);
+}
+function useCommand(database, command) {
+  const literal = typeof command === "string";
+  const name = literal ? command : command.name;
+  const target = useMemo(() => literal ? name : operationRef(name), [literal, name]);
+  return useCallback((args) => database.execute(target, args), [database, target]);
+}
+
+export { useCommand, useLiveQuery };

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

@@ -1,5 +1,5 @@
 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';
+import { C as ClusterCoordinator, A as AcquireControllerLeaseInput, b as AcquireControllerLeaseResult, c as RegisterNodeSessionInput, d as CoordinatorNodeSession, S as SetReplicationGroupStateInput, R as ReplicationGroupState, e as ReplicationGroupWatcher, f as CoordinatorWatchDisposer, g as CompareAndAdvancePrimaryTermInput, h as CompareAndAdvancePrimaryTermResult, U as UpdateInSyncSetInput, i as AdmitNodeToInSyncSetInput, j as UpdateNodeMaintenanceInput, P as PromoteEligibleReplicaInput } from '../../types-BsVabqSI.js';
 
 interface EtcdClusterCoordinatorOptions {
     hosts: string | string[];
@@ -12,12 +12,15 @@ interface EtcdClusterCoordinatorOptions {
     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 grantedNodeSessionLeaseIds;
     private readonly watchers;
+    private readonly groups;
     constructor(options: EtcdClusterCoordinatorOptions);
     tryAcquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
     renewLease(leaseId: string, ttlMs: number): Promise<boolean>;
@@ -34,10 +37,9 @@ declare class EtcdClusterCoordinator implements ClusterCoordinator {
     updateNodeMaintenance(input: UpdateNodeMaintenanceInput): Promise<ReplicationGroupState | null>;
     promoteEligibleReplica(input: PromoteEligibleReplicaInput): Promise<ReplicationGroupState>;
     close(): Promise<void>;
+    private discardSupersededLeases;
     private getLeaseFromKey;
     private trackLease;
-    private updateGroupStateWithRetry;
-    private casGroupState;
 }
 declare function createEtcdCoordinator(options: EtcdClusterCoordinatorOptions): EtcdClusterCoordinator;