@squidcloud/client 1.0.147 → 1.0.149

package/dist/typescript-client/src/query/query-subscription.manager.d.ts

@@ -1,130 +1,131 @@
-import { Alias, ClientRequestId, JoinCondition, Query, QueryResultData, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { Observable, Subject } from 'rxjs';
-import { ClientIdService } from '../client-id.service';
-import { DestructManager } from '../destruct.manager';
-import DocumentIdentityService from '../document-identity.service';
-import { DocumentStore } from '../document-store';
-import { RpcManager } from '../rpc.manager';
-import { QuerySender } from './query-sender';
-import { OngoingQuery } from './query.types';
-export declare const FETCH_BEYOND_LIMIT = 100;
-export declare const LIMIT_UNDERFLOW_TRIGGER = 20;
-export declare class QuerySubscriptionManager {
-    private readonly rpcManager;
-    private readonly clientIdService;
-    private readonly documentStore;
-    private readonly destructManager;
-    private readonly documentIdentityService;
-    private readonly querySender;
-    /**
-     * An observable used by the data manager, the query subscription manager (this class) identifies when a document no
-     * longer has queries that it is part of their result, such document is considered orphan. The data manager will mark
-     * as orphan.
-     */
-    onOrphanDocuments: Subject<string[]>;
-    /** All the currently running queries with their full state. */
-    private readonly ongoingQueries;
-    /**
-     * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
-     * This relation is used for determining whether a document can be safely removed.
-     */
-    private readonly clientRequestIdToLocalDocuments;
-    private readonly localDocumentToClientRequestIds;
-    /**
-     * A data structure for mapping queries to allow reverse queries search (given a document, find all the matching
-     * queries)
-     */
-    private readonly queryMappingManager;
-    private readonly queryResultsSubject;
-    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
-    observeQueryResults(): Observable<QueryResultData>;
-    /**
-     * Returns true if the client knows about this clientRequestId. It may happen that it will return false in the case
-     * that the client unsubscribed from a query but the server sent a mutation update for this clientRequestId.
-     */
-    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
-    /**
-     * Returns the query associated with the given clientRequestId. Throws error if the clientRequestId is not known.
-     */
-    getQuery(clientRequestId: ClientRequestId): Query;
-    /**
-     * A query receives updates from two different sources:
-     * 1 - An initial snapshot from the server or from a parent query
-     * 2 - Incremental updates from the server (or from a parent query before the query is registered)
-     *
-     * If an incremental update is received before the snapshot was received, we cannot process it for this query.
-     * This boolean indicates whether the initial snapshot was received.
-     */
-    setGotInitialResult(clientRequestId: ClientRequestId): void;
-    /** Given a document, returns all the queries that should be notified with the new document properties. */
-    findQueriesForDocument(doc: SquidDocument, squidDocId: SquidDocId): Array<QuerySubscriptionId>;
-    /**
-     * Given the new document's properties, finds all the queries that should be notified with the new properties and
-     * updates the internal mappings (squidDocId --> client request Ids and, clientRequestId --> squidDocIds).
-     * Returns an array with all the previous and current client request ids (basically all the client request ids that
-     * will need to be notified due to the change of properties).
-     */
-    setClientRequestIdsForLocalDoc(squidDocId: SquidDocId, properties: SquidDocument | undefined): Array<ClientRequestId>;
-    /**
-     * Due to an error when syncing a document, all the queries that are subscribed to this document should be notified
-     * and error out.
-     */
-    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
-    /** Notifies to all the given queries (identified by their clientRequestId) with the updated query result. */
-    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
-    private isValidParent;
-    /**
-     * Given an ongoing query, search for candidate ongoing queries that can serve as a parent.
-     * If there is a parent query, the result of that query can be used for serving the current query.
-     * We will still register the current query on the server, but we do not need to run the query, apply security rules,
-     * etc.
-     */
-    private findValidParentOfOngoingQuery;
-    findValidParentOfQuery(query: Query): OngoingQuery | undefined;
-    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean, forceFetchFromServer: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
-    /**
-     * Returns whether the given document ID has a query that has this document ID as a result.
-     * A document without a query is considered "un-tracked".
-     */
-    hasOngoingQueryForDocId(squidDocId: string): boolean;
-    /**
-     * Removes a query from the mapping and updates the orphan documents as needed.
-     */
-    private removeClientRequestIdMapping;
-    /** Register logic for cleaning up the query when it is unsubscribed. */
-    private registerQueryFinalizer;
-    /** Creates a graph of ongoing queries and returns the root of the graph. */
-    private createOngoingQueryGraph;
-    private collectAllObservables;
-    private joinResults;
-    private join;
-    private getOngoingQueriesBfs;
-    private updateOngoingQueryWithNewDataFromSupportingQuery;
-    private allOngoingQueriesGotInitialResult;
-    private completeAllSupportedQueries;
-    private preDestruct;
-    unsubscribe(): void;
-    hasSubscription(clientRequestId: ClientRequestId): boolean;
-    /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
-    private sendQueryToServerOrUseParentQuery;
-    /**
-     * Uses the parent query as the source of data for the given ongoing query until the ongoing query is registered on
-     * the server. It prevents the parent query from being unsubscribed until the query is registered on the server and
-     * the first snapshot is received from the parent query.
-     * 1 - Prevents the parent query from being unsubscribed
-     * 2 - Connects the results of the parent query to the result of the current ongoing query
-     * 3 - Registers the query on the server
-     */
-    private useParentOngoingQuery;
-    /**
-     * Sends the /query request to the server. It:
-     * 1 - Waits for when it is safe to send a query to the server (no in-flight mutations)
-     * 2 - Increments the number of inflightQueriesCount to prevent parallel mutations
-     * 3 - Handles errors
-     * 4 - Marks the query as registered
-     */
-    private sendQueryToServer;
-    /** naive way to refresh queries/subscriptions when we have a new client id */
-    private refreshOngoingQueries;
-    private migrateDocIds;
-}
+import { Alias, ClientRequestId, JoinCondition, Query, QueryResultData, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
+import { Observable, Subject } from 'rxjs';
+import { ClientIdService } from '../client-id.service';
+import { DestructManager } from '../destruct.manager';
+import DocumentIdentityService from '../document-identity.service';
+import { DocumentStore } from '../document-store';
+import { RpcManager } from '../rpc.manager';
+import { QuerySender } from './query-sender';
+import { OngoingQuery } from './query.types';
+export declare const FETCH_BEYOND_LIMIT = 100;
+export declare const LIMIT_UNDERFLOW_TRIGGER = 20;
+export declare class QuerySubscriptionManager {
+    private readonly rpcManager;
+    private readonly clientIdService;
+    private readonly documentStore;
+    private readonly destructManager;
+    private readonly documentIdentityService;
+    private readonly querySender;
+    /**
+     * An observable used by the data manager, the query subscription manager (this class) identifies when a document no
+     * longer has queries that it is part of their result, such document is considered orphan. The data manager will mark
+     * as orphan.
+     */
+    onOrphanDocuments: Subject<string[]>;
+    /** All the currently running queries with their full state. */
+    private readonly ongoingQueries;
+    /**
+     * The two maps below maintain the relation between document ids we know about locally to clientRequestIds (queries).
+     * This relation is used for determining whether a document can be safely removed.
+     */
+    private readonly clientRequestIdToLocalDocuments;
+    private readonly localDocumentToClientRequestIds;
+    /**
+     * A data structure for mapping queries to allow reverse queries search (given a document, find all the matching
+     * queries)
+     */
+    private readonly queryMappingManager;
+    private readonly queryResultsSubject;
+    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService, querySender: QuerySender);
+    observeQueryResults(): Observable<QueryResultData>;
+    /**
+     * Returns true if the client knows about this clientRequestId. It may happen that it will return false in the case
+     * that the client unsubscribed from a query but the server sent a mutation update for this clientRequestId.
+     */
+    hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
+    /**
+     * Returns the query associated with the given clientRequestId. Throws error if the clientRequestId is not known.
+     */
+    getQuery(clientRequestId: ClientRequestId): Query;
+    /**
+     * A query receives updates from three different sources:
+     * 1 - An initial snapshot from the server or from a parent query
+     * 2 - Incremental updates from the server (or from a parent query before the query is registered)
+     * 3 - A new snapshot if the query is refreshed after connection has been lost.
+     *
+     * If an incremental update is received before the snapshot was received, we cannot process it for this query.
+     * This boolean indicates whether the initial snapshot was received.
+     */
+    setGotInitialResult(clientRequestId: ClientRequestId): void;
+    /** Given a document, returns all the queries that should be notified with the new document properties. */
+    findQueriesForDocument(doc: SquidDocument, squidDocId: SquidDocId): Array<QuerySubscriptionId>;
+    /**
+     * Given the new document's properties, finds all the queries that should be notified with the new properties and
+     * updates the internal mappings (squidDocId --> client request Ids and, clientRequestId --> squidDocIds).
+     * Returns an array with all the previous and current client request ids (basically all the client request ids that
+     * will need to be notified due to the change of properties).
+     */
+    setClientRequestIdsForLocalDoc(squidDocId: SquidDocId, properties: SquidDocument | undefined): Array<ClientRequestId>;
+    /**
+     * Due to an error when syncing a document, all the queries that are subscribed to this document should be notified
+     * and error out.
+     */
+    errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
+    /** Notifies to all the given queries (identified by their clientRequestId) with the updated query result. */
+    notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
+    private isValidParent;
+    /**
+     * Given an ongoing query, search for candidate ongoing queries that can serve as a parent.
+     * If there is a parent query, the result of that query can be used for serving the current query.
+     * We will still register the current query on the server, but we do not need to run the query, apply security rules,
+     * etc.
+     */
+    private findValidParentOfOngoingQuery;
+    findValidParentOfQuery(query: Query): OngoingQuery | undefined;
+    processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean, forceFetchFromServer: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
+    /**
+     * Returns whether the given document ID has a query that has this document ID as a result.
+     * A document without a query is considered "un-tracked".
+     */
+    hasOngoingQueryForDocId(squidDocId: string): boolean;
+    /**
+     * Removes a query from the mapping and updates the orphan documents as needed.
+     */
+    private removeClientRequestIdMapping;
+    /** Register logic for cleaning up the query when it is unsubscribed. */
+    private registerQueryFinalizer;
+    /** Creates a graph of ongoing queries and returns the root of the graph. */
+    private createOngoingQueryGraph;
+    private collectAllObservables;
+    private joinResults;
+    private join;
+    private getOngoingQueriesBfs;
+    private updateOngoingQueryWithNewDataFromSupportingQuery;
+    private allOngoingQueriesGotInitialResult;
+    private completeAllSupportedQueries;
+    private preDestruct;
+    unsubscribe(): void;
+    hasSubscription(clientRequestId: ClientRequestId): boolean;
+    /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
+    private sendQueryToServerOrUseParentQuery;
+    /**
+     * Uses the parent query as the source of data for the given ongoing query until the ongoing query is registered on
+     * the server. It prevents the parent query from being unsubscribed until the query is registered on the server and
+     * the first snapshot is received from the parent query.
+     * 1 - Prevents the parent query from being unsubscribed
+     * 2 - Connects the results of the parent query to the result of the current ongoing query
+     * 3 - Registers the query on the server
+     */
+    private useParentOngoingQuery;
+    /**
+     * Sends the /query request to the server. It:
+     * 1 - Waits for when it is safe to send a query to the server (no in-flight mutations)
+     * 2 - Increments the number of inflightQueriesCount to prevent parallel mutations
+     * 3 - Handles errors
+     * 4 - Marks the query as registered
+     */
+    private sendQueryToServer;
+    /** naive way to refresh queries/subscriptions when we have a new client id */
+    private refreshOngoingQueries;
+    private migrateDocIds;
+}

package/dist/typescript-client/src/query/query.types.d.ts

@@ -1,49 +1,49 @@
-import { Alias, ClientRequestId, JoinCondition, Query, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
-export interface OngoingQuery {
-    clientRequestId: ClientRequestId;
-    query: Query;
-    supportedQueries: Array<OngoingQuery>;
-    supportingOngoingQuery?: OngoingQuery;
-    gotInitialResponse: boolean;
-    activated: boolean;
-    joinCondition?: JoinCondition;
-    alias: Alias;
-    dataSubject: BehaviorSubject<Array<SquidDocument> | null>;
-    queryRegistered: BehaviorSubject<boolean>;
-    /**
-     * In case that this query is a parent of another query (that is, the other query is a subset of this query), this
-     * query should not be unsubscribed from the server until we registered the child query in the server.
-     */
-    unsubscribeBlockerCount: BehaviorSubject<number>;
-    subscribe: boolean;
-    /**
-     * In case of joins, and if this ongoing query is the root, this field emits all the supported observables
-     * for example A.join(B, {...some join condition...}).join(C, {...some join condition}.
-     * This field will emit [A.subject.pipe(), B.subject.pipe(), C.subject.pipe()]. Any new supported queries will be
-     * added here.
-     */
-    allObservables?: ReplaySubject<Array<Observable<DocsAndAlias>>>;
-    isEmptyForJoin: boolean;
-    done: boolean;
-    isInFlight: boolean;
-    forceFetchFromServer: boolean;
-    /**
-     * If there's a limit, we request `limit + FETCH_BEYOND_LIMIT` documents from the server.
-     * If we got that many documents, that means there may be even more. In that case, if our result set goes below
-     * `limit + LIMIT_UNDERFLOW_TRIGGER` documents (due to local or remote deletions), we need to resend the query to the
-     * server to potentially get more documents.
-     * If the number of documents is less than `limit + FETCH_BEYOND_LIMIT`, that means there are not that many documents
-     * on the server, so we don't need to resend the query regardless of how small our result size is or becomes.
-     */
-    limitUnderflowState: LimitUnderflowState;
-}
-export declare enum LimitUnderflowState {
-    UNKNOWN = 0,
-    DISABLED = 1,
-    ENABLED = 2
-}
-export interface DocsAndAlias {
-    docs: Array<SquidDocument>;
-    alias: Alias;
-}
+import { Alias, ClientRequestId, JoinCondition, Query, SquidDocument } from '@squidcloud/common';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+export interface OngoingQuery {
+    clientRequestId: ClientRequestId;
+    query: Query;
+    supportedQueries: Array<OngoingQuery>;
+    supportingOngoingQuery?: OngoingQuery;
+    gotInitialResponse: boolean;
+    activated: boolean;
+    joinCondition?: JoinCondition;
+    alias: Alias;
+    dataSubject: BehaviorSubject<Array<SquidDocument> | null>;
+    queryRegistered: BehaviorSubject<boolean>;
+    /**
+     * In case that this query is a parent of another query (that is, the other query is a subset of this query), this
+     * query should not be unsubscribed from the server until we registered the child query in the server.
+     */
+    unsubscribeBlockerCount: BehaviorSubject<number>;
+    subscribe: boolean;
+    /**
+     * In case of joins, and if this ongoing query is the root, this field emits all the supported observables
+     * for example A.join(B, {...some join condition...}).join(C, {...some join condition}.
+     * This field will emit [A.subject.pipe(), B.subject.pipe(), C.subject.pipe()]. Any new supported queries will be
+     * added here.
+     */
+    allObservables?: ReplaySubject<Array<Observable<DocsAndAlias>>>;
+    isEmptyForJoin: boolean;
+    done: boolean;
+    isInFlight: boolean;
+    forceFetchFromServer: boolean;
+    /**
+     * If there's a limit, we request `limit + FETCH_BEYOND_LIMIT` documents from the server.
+     * If we got that many documents, that means there may be even more. In that case, if our result set goes below
+     * `limit + LIMIT_UNDERFLOW_TRIGGER` documents (due to local or remote deletions), we need to resend the query to the
+     * server to potentially get more documents.
+     * If the number of documents is less than `limit + FETCH_BEYOND_LIMIT`, that means there are not that many documents
+     * on the server, so we don't need to resend the query regardless of how small our result size is or becomes.
+     */
+    limitUnderflowState: LimitUnderflowState;
+}
+export declare enum LimitUnderflowState {
+    UNKNOWN = 0,
+    DISABLED = 1,
+    ENABLED = 2
+}
+export interface DocsAndAlias {
+    docs: Array<SquidDocument>;
+    alias: Alias;
+}

package/dist/typescript-client/src/rate-limiter.d.ts

@@ -1,32 +1,32 @@
-export declare class RateLimiter {
-    private readonly capacity;
-    private readonly seconds;
-    private tokens;
-    private lastRefillTimestamp;
-    private readonly refillRatePerMs;
-    /**
-     * Creates a new rate limiter. It limits the number of requests using two parameters:
-     * - capacity: the maximum number of tokens (actions) that can be stored at any given time
-     * - seconds: the number of seconds it takes to refill the bucket to its maximum capacity
-     *
-     * We then can calculate the refillRatePerMs: the number of tokens (actions) that are added to the bucket every
-     * millisecond
-     *
-     * Example:
-     * Say we want to allow maximum 60 requests in a period of 5 seconds. We can create a rate limiter with:
-     * - capacity: 60
-     * - seconds: 5
-     * And we will get refillRatePerMs: 60 / (5 * 1000) = 0.012
-     *
-     * To use:
-     * const rateLimiter = new RateLimiter(60, 5);
-     * await rateLimiter.consume();
-     *
-     * @param capacity
-     * @param refillRatePerMs
-     */
-    constructor(capacity: number, seconds: number);
-    consume(): Promise<void>;
-    private attemptConsume;
-    private refill;
-}
+export declare class RateLimiter {
+    private readonly capacity;
+    private readonly seconds;
+    private tokens;
+    private lastRefillTimestamp;
+    private readonly refillRatePerMs;
+    /**
+     * Creates a new rate limiter. It limits the number of requests using two parameters:
+     * - capacity: the maximum number of tokens (actions) that can be stored at any given time
+     * - seconds: the number of seconds it takes to refill the bucket to its maximum capacity
+     *
+     * We then can calculate the refillRatePerMs: the number of tokens (actions) that are added to the bucket every
+     * millisecond
+     *
+     * Example:
+     * Say we want to allow maximum 60 requests in a period of 5 seconds. We can create a rate limiter with:
+     * - capacity: 60
+     * - seconds: 5
+     * And we will get refillRatePerMs: 60 / (5 * 1000) = 0.012
+     *
+     * To use:
+     * const rateLimiter = new RateLimiter(60, 5);
+     * await rateLimiter.consume();
+     *
+     * @param capacity
+     * @param refillRatePerMs
+     */
+    constructor(capacity: number, seconds: number);
+    consume(): Promise<void>;
+    private attemptConsume;
+    private refill;
+}

package/dist/typescript-client/src/rpc.manager.d.ts

@@ -1,30 +1,30 @@
-import { SupportedSquidRegion } from '@squidcloud/common';
-import { AuthManager } from './auth.manager';
-import { ClientIdService } from './client-id.service';
-import { DestructManager } from './destruct.manager';
-import { BlobAndFilename } from './types';
-export declare class RpcManager {
-    private readonly region;
-    private readonly appId;
-    private readonly authManager;
-    private readonly clientIdService;
-    private readonly staticHeaders;
-    private readonly onGoingRpcCounter;
-    private readonly rateLimiters;
-    constructor(region: SupportedSquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
-    private getAuthHeaders;
-    awaitAllSettled(): Promise<void>;
-    setStaticHeader(key: string, value: string): void;
-    deleteStaticHeader(key: string): void;
-    getStaticHeaders(): Record<string, string>;
-    post<T>(path: string, message: any, files?: Array<File | BlobAndFilename>, filesFieldName?: string): Promise<T>;
-    private tryDeserializing;
-    private getRateLimiterBucket;
-}
-export declare class RpcError extends Error {
-    readonly statusCode: number;
-    readonly statusText: string;
-    readonly headers: Headers;
-    readonly url: string;
-    constructor(statusCode: number, statusText: string, headers: Headers, url: string, message?: string);
-}
+import { SupportedSquidRegion } from '@squidcloud/common';
+import { AuthManager } from './auth.manager';
+import { ClientIdService } from './client-id.service';
+import { DestructManager } from './destruct.manager';
+import { BlobAndFilename } from './types';
+export declare class RpcManager {
+    private readonly region;
+    private readonly appId;
+    private readonly authManager;
+    private readonly clientIdService;
+    private readonly staticHeaders;
+    private readonly onGoingRpcCounter;
+    private readonly rateLimiters;
+    constructor(region: SupportedSquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
+    private getAuthHeaders;
+    awaitAllSettled(): Promise<void>;
+    setStaticHeader(key: string, value: string): void;
+    deleteStaticHeader(key: string): void;
+    getStaticHeaders(): Record<string, string>;
+    post<T>(path: string, message: any, files?: Array<File | BlobAndFilename>, filesFieldName?: string): Promise<T>;
+    private tryDeserializing;
+    private getRateLimiterBucket;
+}
+export declare class RpcError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly url: string;
+    constructor(statusCode: number, statusText: string, headers: Headers, url: string, message?: string);
+}

package/dist/typescript-client/src/secret.client.d.ts

@@ -1,22 +1,22 @@
-import { SecretEntry, SecretKey, SecretValue, SetSecretRequestEntry } from '@squidcloud/common';
-import { RpcManager } from './rpc.manager';
-export declare class SecretClient {
-    private readonly rpcManager;
-    constructor(rpcManager: RpcManager);
-    get(key: SecretKey): Promise<SecretEntry | undefined>;
-    getAll(): Promise<Record<SecretKey, SecretEntry>>;
-    upsert(key: SecretKey, value: SecretValue): Promise<SecretEntry>;
-    upsertMany(entries: Array<SetSecretRequestEntry>): Promise<Array<SecretEntry>>;
-    delete(key: SecretKey): Promise<void>;
-    deleteMany(keys: Array<SecretKey>): Promise<void>;
-    get apiKeys(): ApiKeysSecretClient;
-}
-declare class ApiKeysSecretClient {
-    private readonly rpcManager;
-    constructor(rpcManager: RpcManager);
-    get(key: SecretKey): Promise<SecretEntry | undefined>;
-    getAll(): Promise<Record<SecretKey, SecretEntry>>;
-    upsert(key: SecretKey): Promise<SecretEntry>;
-    delete(key: SecretKey): Promise<void>;
-}
-export {};
+import { SecretEntry, SecretKey, SecretValue, SetSecretRequestEntry } from '@squidcloud/common';
+import { RpcManager } from './rpc.manager';
+export declare class SecretClient {
+    private readonly rpcManager;
+    constructor(rpcManager: RpcManager);
+    get(key: SecretKey): Promise<SecretEntry | undefined>;
+    getAll(): Promise<Record<SecretKey, SecretEntry>>;
+    upsert(key: SecretKey, value: SecretValue): Promise<SecretEntry>;
+    upsertMany(entries: Array<SetSecretRequestEntry>): Promise<Array<SecretEntry>>;
+    delete(key: SecretKey): Promise<void>;
+    deleteMany(keys: Array<SecretKey>): Promise<void>;
+    get apiKeys(): ApiKeysSecretClient;
+}
+declare class ApiKeysSecretClient {
+    private readonly rpcManager;
+    constructor(rpcManager: RpcManager);
+    get(key: SecretKey): Promise<SecretEntry | undefined>;
+    getAll(): Promise<Record<SecretKey, SecretEntry>>;
+    upsert(key: SecretKey): Promise<SecretEntry>;
+    delete(key: SecretKey): Promise<void>;
+}
+export {};

package/dist/typescript-client/src/socket.manager.d.ts

@@ -1,43 +1,43 @@
-import { MessageFromClient, MessageToClient, SupportedSquidRegion } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { AuthManager } from './auth.manager';
-import { ClientIdService } from './client-id.service';
-import { DestructManager } from './destruct.manager';
-export declare class SocketManager {
-    private readonly clientIdService;
-    private readonly region;
-    private readonly appId;
-    private readonly messageNotificationWrapper;
-    private readonly destructManager;
-    private readonly authManager;
-    private readonly webSocketObserver;
-    private readonly allMessagesObserver;
-    private readonly connectionReady;
-    private readonly seenMessageIds;
-    private socket;
-    private destructSubject;
-    private lastTick;
-    /**
-     * On a client disconnecting, we wait for a bit to see if the client reconnects,
-     * if no reconnect happens within the timeout, we consider the client to be too old.
-     * This value means we wait for 5 minutes before considering the client to be too old.
-     * Note: we make this a function so that we can easily override it in tests.
-     */
-    private clientTooOldThreshold;
-    private tickInterval;
-    constructor(clientIdService: ClientIdService, region: SupportedSquidRegion, appId: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, authManager: AuthManager);
-    refreshClient(): void;
-    tick(): void;
-    observeNotifications<T extends MessageToClient>(): Observable<T>;
-    observeConnectionReady(): Observable<boolean>;
-    sendMessage(message: MessageFromClient): void;
-    private sendMessageAsync;
-    /**  Sends 'kill' message ignoring 'connectionReady' observable. */
-    private sendKillMessage;
-    private connect;
-    disconnect(): void;
-    private onConnectionReady;
-    private onMessage;
-    private setupMessageAcknowledgments;
-    private destruct;
-}
+import { MessageFromClient, MessageToClient, SupportedSquidRegion } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { AuthManager } from './auth.manager';
+import { ClientIdService } from './client-id.service';
+import { DestructManager } from './destruct.manager';
+export declare class SocketManager {
+    private readonly clientIdService;
+    private readonly region;
+    private readonly appId;
+    private readonly messageNotificationWrapper;
+    private readonly destructManager;
+    private readonly authManager;
+    private readonly webSocketObserver;
+    private readonly allMessagesObserver;
+    private readonly connectionReady;
+    private readonly seenMessageIds;
+    private socket;
+    private destructSubject;
+    private lastTick;
+    /**
+     * On a client disconnecting, we wait for a bit to see if the client reconnects,
+     * if no reconnect happens within the timeout, we consider the client to be too old.
+     * This value means we wait for 5 minutes before considering the client to be too old.
+     * Note: we make this a function so that we can easily override it in tests.
+     */
+    private clientTooOldThreshold;
+    private tickInterval;
+    constructor(clientIdService: ClientIdService, region: SupportedSquidRegion, appId: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, authManager: AuthManager);
+    refreshClient(): void;
+    tick(): void;
+    observeNotifications<T extends MessageToClient>(): Observable<T>;
+    observeConnectionReady(): Observable<boolean>;
+    sendMessage(message: MessageFromClient): void;
+    private sendMessageAsync;
+    /**  Sends 'kill' message ignoring 'connectionReady' observable. */
+    private sendKillMessage;
+    private connect;
+    disconnect(): void;
+    private onConnectionReady;
+    private onMessage;
+    private setupMessageAcknowledgments;
+    private destruct;
+}