@fabriktor/client 0.0.28 → 0.0.31

package/dist/src/calls/calls.d.ts

@@ -0,0 +1,34 @@
+import { type Event, type InEvent, type OperationResult, type PLCallsMintVideoToken } from "@fabriktor/schema";
+import type { TokenProvider } from "../core/auth.js";
+import type { DeleteManyOptionsCRUD, DeleteOneOptionsCRUD, FindOneOptionsCRUD, InsertOneOptionsCRUD, OperationResultOf, QueryOptionsCRUD, ReplaceOneOptionsCRUD } from "../core/crud.js";
+import type { HTTPDoer } from "../core/http.js";
+export type MintVideoTokenOptions = PLCallsMintVideoToken;
+export type CallsClientOptions = {
+    http: HTTPDoer;
+    base_url: string;
+    get_token?: TokenProvider;
+};
+export interface CallsOperator {
+    queryEvents(opts?: QueryOptionsCRUD): Promise<OperationResultOf<Event[]>>;
+    insertOneEvent(opts: InsertOneOptionsCRUD<InEvent>): Promise<OperationResult>;
+    findOneEvent(opts: FindOneOptionsCRUD): Promise<OperationResultOf<Event>>;
+    replaceOneEvent(opts: ReplaceOneOptionsCRUD<InEvent>): Promise<OperationResult>;
+    deleteOneEvent(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteManyEvents(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    mintVideoToken(opts: MintVideoTokenOptions): Promise<OperationResultOf<string>>;
+}
+export declare class CallsClient implements CallsOperator {
+    private events;
+    private http;
+    private base_url;
+    private get_token?;
+    constructor(opts: CallsClientOptions);
+    queryEvents(opts?: QueryOptionsCRUD): Promise<OperationResultOf<Event[]>>;
+    insertOneEvent(opts: InsertOneOptionsCRUD<InEvent>): Promise<OperationResult>;
+    findOneEvent(opts: FindOneOptionsCRUD): Promise<OperationResultOf<Event>>;
+    replaceOneEvent(opts: ReplaceOneOptionsCRUD<InEvent>): Promise<OperationResult>;
+    deleteOneEvent(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteManyEvents(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    mintVideoToken(opts: MintVideoTokenOptions): Promise<OperationResultOf<string>>;
+}
+export declare function newCallsClient(opts: CallsClientOptions): CallsClient;

package/dist/src/calls/calls.js

@@ -0,0 +1,65 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { ColCallsEvents, HTTPMethodPost, PathCallsMint, PathCallsVidTokens, SvcCalls, } from "@fabriktor/schema";
+import { requiredToken } from "../core/auth.js";
+import { newCRUDClient } from "../core/crud.js";
+import { buildPath } from "../core/path.js";
+export class CallsClient {
+    events;
+    http;
+    base_url;
+    get_token;
+    constructor(opts) {
+        this.events = newCRUDClient({
+            http: opts.http,
+            base_url: opts.base_url,
+            svc: SvcCalls,
+            col: ColCallsEvents,
+            get_token: opts.get_token,
+        });
+        this.http = opts.http;
+        this.base_url = opts.base_url;
+        this.get_token = opts.get_token;
+    }
+    async queryEvents(opts) {
+        return await this.events.query(opts);
+    }
+    async insertOneEvent(opts) {
+        return await this.events.insertOne(opts);
+    }
+    async findOneEvent(opts) {
+        return await this.events.findOne(opts);
+    }
+    async replaceOneEvent(opts) {
+        return await this.events.replaceOne(opts);
+    }
+    async deleteOneEvent(opts) {
+        return await this.events.deleteOne(opts);
+    }
+    async deleteManyEvents(opts) {
+        return await this.events.deleteMany(opts);
+    }
+    async mintVideoToken(opts) {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: vidTokenPath(PathCallsMint),
+            method: HTTPMethodPost,
+            token,
+            body: opts,
+        });
+    }
+}
+export function newCallsClient(opts) {
+    return new CallsClient(opts);
+}
+function vidTokenPath(action) {
+    return buildPath({
+        svc: SvcCalls,
+        col: PathCallsVidTokens,
+        action,
+    });
+}

package/dist/src/chat/chat.d.ts

@@ -0,0 +1,97 @@
+import { type Chat, type ChatRoom, type ChatRoomMember, type ID, type InChat, type InChatRoom, type InChatRoomMember, type OperationResult, type PLChatEnsure, type PLChatReact } from "@fabriktor/schema";
+import type { TokenProvider } from "../core/auth.js";
+import type { DeleteManyOptionsCRUD, DeleteOneOptionsCRUD, FindOneOptionsCRUD, InsertOneOptionsCRUD, OperationResultOf, QueryOptionsCRUD, ReplaceOneOptionsCRUD, SearchManyOptionsCRUD, SearchResultOf } from "../core/crud.js";
+import type { HTTPDoer } from "../core/http.js";
+export type ReactChatOptions = PLChatReact;
+export type EnsureChatRoomOptions = PLChatEnsure;
+export type WSMessageHandler<T> = (v: T, ev: MessageEvent<string>) => void;
+export type WSErrorHandler = (ev: Event) => void;
+export type WSCloseHandler = (ev: CloseEvent) => void;
+export type WSConnection<T> = {
+    socket: WebSocket;
+    close(code?: number, reason?: string): void;
+};
+export type WSChatsOptions = {
+    owner_id: string;
+    chat_room_id: string;
+    on_message: WSMessageHandler<Chat>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type WSChatRoomsOptions = {
+    id: string;
+    on_message: WSMessageHandler<ChatRoom>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type WSChatRoomOptions = {
+    owner_id: string;
+    on_message: WSMessageHandler<ChatRoom>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type ChatClientOptions = {
+    http: HTTPDoer;
+    base_url: string;
+    get_token?: TokenProvider;
+};
+export interface ChatOperator {
+    queryChats(opts?: QueryOptionsCRUD): Promise<OperationResultOf<Chat[]>>;
+    queryChatRooms(opts?: QueryOptionsCRUD): Promise<OperationResultOf<ChatRoom[]>>;
+    queryChatRoomMembers(opts?: QueryOptionsCRUD): Promise<OperationResultOf<ChatRoomMember[]>>;
+    insertOneChat(opts: InsertOneOptionsCRUD<InChat>): Promise<OperationResult>;
+    findOneChat(opts: FindOneOptionsCRUD): Promise<OperationResultOf<Chat>>;
+    findOneChatRoom(opts: FindOneOptionsCRUD): Promise<OperationResultOf<ChatRoom>>;
+    findOneChatRoomMember(opts: FindOneOptionsCRUD): Promise<OperationResultOf<ChatRoomMember>>;
+    replaceOneChat(opts: ReplaceOneOptionsCRUD<InChat>): Promise<OperationResult>;
+    replaceOneChatRoom(opts: ReplaceOneOptionsCRUD<InChatRoom>): Promise<OperationResult>;
+    replaceOneChatRoomMember(opts: ReplaceOneOptionsCRUD<InChatRoomMember>): Promise<OperationResult>;
+    deleteOneChat(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteOneChatRoom(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteOneChatRoomMember(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteManyChats(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    deleteManyChatRooms(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    deleteManyChatRoomMembers(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    searchManyChats(opts?: SearchManyOptionsCRUD): Promise<OperationResultOf<SearchResultOf<Chat>>>;
+    searchManyChatRooms(opts?: SearchManyOptionsCRUD): Promise<OperationResultOf<SearchResultOf<ChatRoom>>>;
+    searchManyChatRoomMembers(opts?: SearchManyOptionsCRUD): Promise<OperationResultOf<SearchResultOf<ChatRoomMember>>>;
+    reactChat(opts: ReactChatOptions): Promise<void>;
+    ensureChatRoom(opts: EnsureChatRoomOptions): Promise<ID>;
+    wsChats(opts: WSChatsOptions): Promise<WSConnection<Chat>>;
+    wsChatRooms(opts: WSChatRoomsOptions): Promise<WSConnection<ChatRoom>>;
+    wsChatRoom(opts: WSChatRoomOptions): Promise<WSConnection<ChatRoom>>;
+}
+export declare class ChatClient implements ChatOperator {
+    private chats;
+    private chat_rooms;
+    private chat_room_members;
+    private http;
+    private base_url;
+    private get_token?;
+    constructor(opts: ChatClientOptions);
+    queryChats(opts?: QueryOptionsCRUD): Promise<OperationResultOf<Chat[]>>;
+    queryChatRooms(opts?: QueryOptionsCRUD): Promise<OperationResultOf<ChatRoom[]>>;
+    queryChatRoomMembers(opts?: QueryOptionsCRUD): Promise<OperationResultOf<ChatRoomMember[]>>;
+    insertOneChat(opts: InsertOneOptionsCRUD<InChat>): Promise<OperationResult>;
+    findOneChat(opts: FindOneOptionsCRUD): Promise<OperationResultOf<Chat>>;
+    findOneChatRoom(opts: FindOneOptionsCRUD): Promise<OperationResultOf<ChatRoom>>;
+    findOneChatRoomMember(opts: FindOneOptionsCRUD): Promise<OperationResultOf<ChatRoomMember>>;
+    replaceOneChat(opts: ReplaceOneOptionsCRUD<InChat>): Promise<OperationResult>;
+    replaceOneChatRoom(opts: ReplaceOneOptionsCRUD<InChatRoom>): Promise<OperationResult>;
+    replaceOneChatRoomMember(opts: ReplaceOneOptionsCRUD<InChatRoomMember>): Promise<OperationResult>;
+    deleteOneChat(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteOneChatRoom(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteOneChatRoomMember(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    deleteManyChats(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    deleteManyChatRooms(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    deleteManyChatRoomMembers(opts?: DeleteManyOptionsCRUD): Promise<OperationResultOf<number>>;
+    searchManyChats(opts?: SearchManyOptionsCRUD): Promise<OperationResultOf<SearchResultOf<Chat>>>;
+    searchManyChatRooms(opts?: SearchManyOptionsCRUD): Promise<OperationResultOf<SearchResultOf<ChatRoom>>>;
+    searchManyChatRoomMembers(opts?: SearchManyOptionsCRUD): Promise<OperationResultOf<SearchResultOf<ChatRoomMember>>>;
+    reactChat(opts: ReactChatOptions): Promise<void>;
+    ensureChatRoom(opts: EnsureChatRoomOptions): Promise<ID>;
+    wsChats(opts: WSChatsOptions): Promise<WSConnection<Chat>>;
+    wsChatRooms(opts: WSChatRoomsOptions): Promise<WSConnection<ChatRoom>>;
+    wsChatRoom(opts: WSChatRoomOptions): Promise<WSConnection<ChatRoom>>;
+}
+export declare function newChatClient(opts: ChatClientOptions): ChatClient;

package/dist/src/chat/chat.js

@@ -0,0 +1,224 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { ColChatChatRoomMembers, ColChatChatRooms, ColChatChats, HTTPMethodPost, PathChatEnsure, PathChatReact, PathChatWS, PathChatWSMine, SvcChat, } from "@fabriktor/schema";
+import { requiredToken } from "../core/auth.js";
+import { queryParam, queryParams, withQuery } from "../core/col.js";
+import { newCRUDClient } from "../core/crud.js";
+import { buildPath } from "../core/path.js";
+const protocolFirebase = "firebase";
+const schemeHTTP = "http:";
+const schemeHTTPS = "https:";
+const schemeWS = "ws:";
+const schemeWSS = "wss:";
+export class ChatClient {
+    chats;
+    chat_rooms;
+    chat_room_members;
+    http;
+    base_url;
+    get_token;
+    constructor(opts) {
+        this.chats = newCRUDClient({
+            http: opts.http,
+            base_url: opts.base_url,
+            svc: SvcChat,
+            col: ColChatChats,
+            get_token: opts.get_token,
+        });
+        this.chat_rooms = newCRUDClient({
+            http: opts.http,
+            base_url: opts.base_url,
+            svc: SvcChat,
+            col: ColChatChatRooms,
+            get_token: opts.get_token,
+        });
+        this.chat_room_members = newCRUDClient({
+            http: opts.http,
+            base_url: opts.base_url,
+            svc: SvcChat,
+            col: ColChatChatRoomMembers,
+            get_token: opts.get_token,
+        });
+        this.http = opts.http;
+        this.base_url = opts.base_url;
+        this.get_token = opts.get_token;
+    }
+    async queryChats(opts) {
+        return await this.chats.query(opts);
+    }
+    async queryChatRooms(opts) {
+        return await this.chat_rooms.query(opts);
+    }
+    async queryChatRoomMembers(opts) {
+        return await this.chat_room_members.query(opts);
+    }
+    async insertOneChat(opts) {
+        return await this.chats.insertOne(opts);
+    }
+    async findOneChat(opts) {
+        return await this.chats.findOne(opts);
+    }
+    async findOneChatRoom(opts) {
+        return await this.chat_rooms.findOne(opts);
+    }
+    async findOneChatRoomMember(opts) {
+        return await this.chat_room_members.findOne(opts);
+    }
+    async replaceOneChat(opts) {
+        return await this.chats.replaceOne(opts);
+    }
+    async replaceOneChatRoom(opts) {
+        return await this.chat_rooms.replaceOne(opts);
+    }
+    async replaceOneChatRoomMember(opts) {
+        return await this.chat_room_members.replaceOne(opts);
+    }
+    async deleteOneChat(opts) {
+        return await this.chats.deleteOne(opts);
+    }
+    async deleteOneChatRoom(opts) {
+        return await this.chat_rooms.deleteOne(opts);
+    }
+    async deleteOneChatRoomMember(opts) {
+        return await this.chat_room_members.deleteOne(opts);
+    }
+    async deleteManyChats(opts) {
+        return await this.chats.deleteMany(opts);
+    }
+    async deleteManyChatRooms(opts) {
+        return await this.chat_rooms.deleteMany(opts);
+    }
+    async deleteManyChatRoomMembers(opts) {
+        return await this.chat_room_members.deleteMany(opts);
+    }
+    async searchManyChats(opts) {
+        return await this.chats.searchMany(opts);
+    }
+    async searchManyChatRooms(opts) {
+        return await this.chat_rooms.searchMany(opts);
+    }
+    async searchManyChatRoomMembers(opts) {
+        return await this.chat_room_members.searchMany(opts);
+    }
+    async reactChat(opts) {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: chatPath(PathChatReact),
+            method: HTTPMethodPost,
+            token,
+            body: opts,
+        });
+    }
+    async ensureChatRoom(opts) {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: chatRoomPath(PathChatEnsure),
+            method: HTTPMethodPost,
+            token,
+            body: opts,
+        });
+    }
+    async wsChats(opts) {
+        const token = await requiredToken(this.get_token);
+        return openWS({
+            base_url: this.base_url,
+            path: withQuery(chatPath(PathChatWS), {
+                query: queryParams({
+                    owner_id: opts.owner_id,
+                    chat_room_id: opts.chat_room_id,
+                }),
+            }),
+            token,
+            on_message: opts.on_message,
+            on_error: opts.on_error,
+            on_close: opts.on_close,
+        });
+    }
+    async wsChatRooms(opts) {
+        const token = await requiredToken(this.get_token);
+        return openWS({
+            base_url: this.base_url,
+            path: withQuery(chatRoomPath(PathChatWS), {
+                query: queryParam("id", opts.id),
+            }),
+            token,
+            on_message: opts.on_message,
+            on_error: opts.on_error,
+            on_close: opts.on_close,
+        });
+    }
+    async wsChatRoom(opts) {
+        const token = await requiredToken(this.get_token);
+        return openWS({
+            base_url: this.base_url,
+            path: withQuery(chatRoomPath(PathChatWSMine), {
+                query: queryParam("owner_id", opts.owner_id),
+            }),
+            token,
+            on_message: opts.on_message,
+            on_error: opts.on_error,
+            on_close: opts.on_close,
+        });
+    }
+}
+export function newChatClient(opts) {
+    return new ChatClient(opts);
+}
+function chatPath(action) {
+    return buildPath({
+        svc: SvcChat,
+        col: ColChatChats,
+        action,
+    });
+}
+function chatRoomPath(action) {
+    return buildPath({
+        svc: SvcChat,
+        col: ColChatChatRooms,
+        action,
+    });
+}
+function openWS(opts) {
+    const socket = new WebSocket(wsURL(opts.base_url, opts.path), [
+        protocolFirebase,
+        opts.token,
+    ]);
+    socket.addEventListener("message", (ev) => {
+        if (typeof ev.data !== "string") {
+            return;
+        }
+        opts.on_message(JSON.parse(ev.data), ev);
+    });
+    if (opts.on_error !== undefined) {
+        socket.addEventListener("error", opts.on_error);
+    }
+    if (opts.on_close !== undefined) {
+        socket.addEventListener("close", opts.on_close);
+    }
+    return {
+        socket,
+        close(code, reason) {
+            socket.close(code, reason);
+        },
+    };
+}
+function wsURL(base, path) {
+    const u = new URL(path.replace(/^\/+/g, ""), ensureSlash(base));
+    if (u.protocol === schemeHTTPS) {
+        u.protocol = schemeWSS;
+        return u.toString();
+    }
+    if (u.protocol === schemeHTTP) {
+        u.protocol = schemeWS;
+        return u.toString();
+    }
+    return u.toString();
+}
+function ensureSlash(x) {
+    return x.endsWith("/") ? x : `${x}/`;
+}

package/dist/src/contacts/contacts.d.ts

@@ -0,0 +1,37 @@
+import { type Contact, type ID, type InContact, type OperationResult, type PLContactsGenerateQR, type Signal } from "@fabriktor/schema";
+import type { TokenProvider } from "../core/auth.js";
+import type { DeleteOneOptionsCRUD, FindOneOptionsCRUD, InsertOneOptionsCRUD, OperationResultOf, ReplaceOneOptionsCRUD } from "../core/crud.js";
+import type { HTTPDoer } from "../core/http.js";
+export type GenerateQROptions = PLContactsGenerateQR;
+export type SignalOptions = Signal;
+export type ContactsClientOptions = {
+    http: HTTPDoer;
+    base_url: string;
+    get_token?: TokenProvider;
+};
+export interface ContactsOperator {
+    insertOneContact(opts: InsertOneOptionsCRUD<InContact>): Promise<OperationResult>;
+    findOneContact(opts: FindOneOptionsCRUD): Promise<OperationResultOf<Contact>>;
+    replaceOneContact(opts: ReplaceOneOptionsCRUD<InContact>): Promise<OperationResult>;
+    deleteOneContact(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    signal(opts: SignalOptions): Promise<OperationResultOf<ID[]>>;
+    suggest(): Promise<OperationResultOf<ID[]>>;
+    generateQR(opts: GenerateQROptions): Promise<void>;
+    findContacts(): Promise<OperationResultOf<Contact[]>>;
+}
+export declare class ContactsClient implements ContactsOperator {
+    private contacts;
+    private http;
+    private base_url;
+    private get_token?;
+    constructor(opts: ContactsClientOptions);
+    insertOneContact(opts: InsertOneOptionsCRUD<InContact>): Promise<OperationResult>;
+    findOneContact(opts: FindOneOptionsCRUD): Promise<OperationResultOf<Contact>>;
+    replaceOneContact(opts: ReplaceOneOptionsCRUD<InContact>): Promise<OperationResult>;
+    deleteOneContact(opts: DeleteOneOptionsCRUD): Promise<OperationResult>;
+    signal(opts: SignalOptions): Promise<OperationResultOf<ID[]>>;
+    suggest(): Promise<OperationResultOf<ID[]>>;
+    generateQR(opts: GenerateQROptions): Promise<void>;
+    findContacts(): Promise<OperationResultOf<Contact[]>>;
+}
+export declare function newContactsClient(opts: ContactsClientOptions): ContactsClient;

package/dist/src/contacts/contacts.js

@@ -0,0 +1,94 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { ColContactsContacts, ColContactsSignals, HTTPMethodGet, HTTPMethodPost, PathContactsFind, PathContactsQR, PathContactsSignal, PathContactsSuggest, SvcContacts, } from "@fabriktor/schema";
+import { requiredToken } from "../core/auth.js";
+import { newCRUDClient } from "../core/crud.js";
+import { buildPath } from "../core/path.js";
+export class ContactsClient {
+    contacts;
+    http;
+    base_url;
+    get_token;
+    constructor(opts) {
+        this.contacts = newCRUDClient({
+            http: opts.http,
+            base_url: opts.base_url,
+            svc: SvcContacts,
+            col: ColContactsContacts,
+            get_token: opts.get_token,
+        });
+        this.http = opts.http;
+        this.base_url = opts.base_url;
+        this.get_token = opts.get_token;
+    }
+    async insertOneContact(opts) {
+        return await this.contacts.insertOne(opts);
+    }
+    async findOneContact(opts) {
+        return await this.contacts.findOne(opts);
+    }
+    async replaceOneContact(opts) {
+        return await this.contacts.replaceOne(opts);
+    }
+    async deleteOneContact(opts) {
+        return await this.contacts.deleteOne(opts);
+    }
+    async signal(opts) {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: signalPath(PathContactsSignal),
+            method: HTTPMethodPost,
+            token,
+            body: opts,
+        });
+    }
+    async suggest() {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: contactPath(PathContactsSuggest),
+            method: HTTPMethodGet,
+            token,
+        });
+    }
+    async generateQR(opts) {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: contactPath(PathContactsQR),
+            method: HTTPMethodPost,
+            token,
+            body: opts,
+        });
+    }
+    async findContacts() {
+        const token = await requiredToken(this.get_token);
+        return await this.http.do({
+            base_url: this.base_url,
+            path: contactPath(PathContactsFind),
+            method: HTTPMethodGet,
+            token,
+        });
+    }
+}
+export function newContactsClient(opts) {
+    return new ContactsClient(opts);
+}
+function contactPath(action) {
+    return buildPath({
+        svc: SvcContacts,
+        col: ColContactsContacts,
+        action,
+    });
+}
+function signalPath(action) {
+    return buildPath({
+        svc: SvcContacts,
+        col: ColContactsSignals,
+        action,
+    });
+}

package/dist/src/core/col.d.ts

@@ -1,5 +1,8 @@
+export type FieldOf<T> = Extract<keyof T, string>;
 export type QueryValue = string | number | boolean | undefined | null;
-export type QueryOptions = Record<string, QueryValue | QueryValue[]>;
+export type QueryInputValue = QueryValue | QueryValue[];
+export type QueryOptions = Record<string, QueryInputValue>;
+export type TypedQueryOptions<T> = Partial<Record<FieldOf<T>, QueryInputValue>>;
 export type CollectionPathOptions = {
     svc: string;
     col: string;
@@ -12,4 +15,7 @@ export type BuildQueryOptions = {
 };
 export declare function collectionPath(opts: CollectionPathOptions): string;
 export declare function idPath(opts: IDPathOptions): string;
+export declare function queryParam<T>(key: FieldOf<T>, value: QueryInputValue): QueryOptions;
+export declare function queryParams<T>(query: TypedQueryOptions<T>): QueryOptions;
+export declare function mergeQueryOptions(...queries: Array<QueryOptions | undefined>): QueryOptions;
 export declare function withQuery(path: string, opts?: BuildQueryOptions): string;

package/dist/src/core/col.js

@@ -17,26 +17,23 @@ export function idPath(opts) {
         id: opts.id,
     });
 }
+export function queryParam(key, value) {
+    return { [key]: value };
+}
+export function queryParams(query) {
+    return query;
+}
+export function mergeQueryOptions(...queries) {
+    return Object.assign({}, ...queries);
+}
 export function withQuery(path, opts) {
     const query = opts?.query;
-    if (!query) {
+    if (query === undefined) {
         return path;
     }
     const params = new URLSearchParams();
     for (const [key, value] of Object.entries(query)) {
-        if (value === undefined || value === null) {
-            continue;
-        }
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (item === undefined || item === null) {
-                    continue;
-                }
-                params.append(key, String(item));
-            }
-            continue;
-        }
-        params.set(key, String(value));
+        appendQueryValue(params, key, value);
     }
     const raw = params.toString();
     if (raw === "") {
@@ -44,3 +41,21 @@ export function withQuery(path, opts) {
     }
     return `${path}?${raw}`;
 }
+function appendQueryValue(params, key, value) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            appendQuerySingleValue(params, key, item);
+        }
+        return;
+    }
+    appendQuerySingleValue(params, key, value);
+}
+function appendQuerySingleValue(params, key, value) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    params.append(key, String(value));
+}

package/dist/src/core/crud.d.ts

@@ -1,7 +1,7 @@
 import { OperationResultValueKey, SearchResultResultsKey, type OperationResult, type SearchResult, type UpsertResult } from "@fabriktor/schema";
 import type { TokenProvider } from "./auth.js";
-import type { HTTPDoer } from "./http.js";
 import { type QueryOptions } from "./col.js";
+import type { HTTPDoer } from "./http.js";
 export type OperationResultOf<T> = Omit<OperationResult, typeof OperationResultValueKey> & {
     [OperationResultValueKey]?: T;
 };

package/dist/src/core/crud.js

@@ -3,7 +3,7 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-import { HTTPMethodDelete, HTTPMethodGet, HTTPMethodPatch, HTTPMethodPost, PathSearch, OperationResultValueKey, SearchResultResultsKey, } from "@fabriktor/schema";
+import { HTTPMethodDelete, HTTPMethodGet, HTTPMethodPatch, HTTPMethodPost, OperationResultValueKey, PathSearch, SearchResultResultsKey, } from "@fabriktor/schema";
 import { requiredToken } from "./auth.js";
 import { collectionPath, idPath, withQuery } from "./col.js";
 import { buildPath } from "./path.js";

package/dist/src/core/http.d.ts

@@ -1,10 +1,9 @@
 import { HTTPMethodDelete, HTTPMethodGet, HTTPMethodPatch, HTTPMethodPost } from "@fabriktor/schema";
-import type { OperationResult } from "@fabriktor/schema";
 import type { IdempotencyStore } from "./idempotency.js";
+export declare const headerAuthorization = "authorization";
+export declare const headerContentType = "content-type";
+export declare const prefixBearer = "Bearer";
 export type Method = typeof HTTPMethodGet | typeof HTTPMethodPost | typeof HTTPMethodPatch | typeof HTTPMethodDelete;
-export type Op<T> = Omit<OperationResult, "value"> & {
-    value?: T;
-};
 export type HTTPOptions<T> = {
     base_url: string;
     path: string;

package/dist/src/core/http.js

@@ -6,9 +6,9 @@
 import { MimeJSON, } from "@fabriktor/schema";
 import { errFromHTTP, errHTTPRequestFailed, errHTTPResponseInvalid, } from "./err.js";
 import { applyIdempotencyHeader, DefaultIdempotencyStore, } from "./idempotency.js";
-const headerAuthorization = "authorization";
-const headerContentType = "content-type";
-const prefixBearer = "Bearer";
+export const headerAuthorization = "authorization";
+export const headerContentType = "content-type";
+export const prefixBearer = "Bearer";
 export class WebFetcher {
     async fetch(input, init) {
         return await fetch(input, init);