prostgles-client 4.0.172 → 4.0.173

package/dist/getDBO.d.ts

@@ -0,0 +1,19 @@
+import { type ClientSchema, type TableSchemaForClient } from "prostgles-types";
+import { type InitOptions, type DBHandlerClient } from "./prostgles";
+import type { SyncedTable } from "./SyncedTable/SyncedTable";
+import type { getSyncHandler } from "./syncHandler";
+import type { getSubscriptionHandler } from "./subscriptionHandler";
+type Args = {
+    schema: TableSchemaForClient;
+    onDebug: InitOptions["onDebug"];
+    socket: InitOptions["socket"];
+    joinTables: ClientSchema["joinTables"];
+    syncedTable: typeof SyncedTable | undefined;
+    syncHandler: ReturnType<typeof getSyncHandler>;
+    subscriptionHandler: ReturnType<typeof getSubscriptionHandler>;
+};
+export declare const getDBO: ({ schema, onDebug, syncedTable, syncHandler, subscriptionHandler, socket, joinTables }: Args) => {
+    dbo: Partial<DBHandlerClient>;
+};
+export {};
+//# sourceMappingURL=getDBO.d.ts.map

package/dist/getDBO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDBO.d.ts","sourceRoot":"","sources":["../lib/getDBO.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,YAAY,EAA+B,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACtI,OAAO,EAAE,KAAK,WAAW,EAA6C,KAAK,eAAe,EAAmC,MAAM,aAAa,CAAC;AACjJ,OAAO,KAAK,EAAQ,WAAW,EAAwB,MAAM,2BAA2B,CAAC;AACzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAGpE,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,oBAAoB,CAAC;IAC7B,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;IACvC,WAAW,EAAE,OAAO,WAAW,GAAG,SAAS,CAAC;IAC5C,WAAW,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IAC/C,mBAAmB,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;CAChE,CAAA;AAID,eAAO,MAAM,MAAM,2FAA4F,IAAI;;CAoIlH,CAAA"}

package/dist/getDBO.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDBO = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const prostgles_1 = require("./prostgles");
+const preffix = prostgles_types_1.CHANNELS._preffix;
+const getDBO = ({ schema, onDebug, syncedTable, syncHandler, subscriptionHandler, socket, joinTables }) => {
+    const dbo = JSON.parse(JSON.stringify(schema));
+    /* Building DBO object */
+    const checkSubscriptionArgs = (basicFilter, options, onChange, onError) => {
+        if (basicFilter !== undefined && !(0, prostgles_types_1.isObject)(basicFilter) || options !== undefined && !(0, prostgles_types_1.isObject)(options) || !(typeof onChange === "function") || onError !== undefined && typeof onError !== "function") {
+            throw "Expecting: ( basicFilter<object>, options<object>, onChange<function> , onError?<function>) but got something else";
+        }
+    };
+    const sub_commands = ["subscribe", "subscribeOne"];
+    (0, prostgles_types_1.getKeys)(dbo).forEach(tableName => {
+        const all_commands = Object.keys(dbo[tableName]);
+        const dboTable = dbo[tableName];
+        all_commands
+            .sort((a, b) => sub_commands.includes(a) - sub_commands.includes(b))
+            .forEach(command => {
+            if (command === "sync") {
+                dboTable._syncInfo = { ...dboTable[command] };
+                if (syncedTable) {
+                    dboTable.getSync = async (filter, params = {}) => {
+                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: "getSync", tableName, data: { filter, params } }));
+                        return syncedTable.create({
+                            name: tableName,
+                            onDebug: onDebug,
+                            filter,
+                            db: dbo,
+                            ...params
+                        });
+                    };
+                    const upsertSyncTable = async (basicFilter = {}, options = {}, onError) => {
+                        const syncName = `${tableName}.${JSON.stringify(basicFilter)}.${JSON.stringify((0, prostgles_types_1.omitKeys)(options, ["handlesOnData"]))}`;
+                        if (!syncHandler.syncedTables[syncName]) {
+                            syncHandler.syncedTables[syncName] = await syncedTable.create({
+                                ...options,
+                                onDebug: onDebug,
+                                name: tableName,
+                                filter: basicFilter,
+                                db: dbo,
+                                onError
+                            });
+                        }
+                        return syncHandler.syncedTables[syncName];
+                    };
+                    const sync = async (basicFilter, options = { handlesOnData: true, select: "*" }, onChange, onError) => {
+                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: "sync", tableName, data: { basicFilter, options } }));
+                        checkSubscriptionArgs(basicFilter, options, onChange, onError);
+                        const s = await upsertSyncTable(basicFilter, options, onError);
+                        return await s.sync(onChange, options.handlesOnData);
+                    };
+                    const syncOne = async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {
+                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: "syncOne", tableName, data: { basicFilter, options } }));
+                        checkSubscriptionArgs(basicFilter, options, onChange, onError);
+                        const s = await upsertSyncTable(basicFilter, options, onError);
+                        return await s.syncOne(basicFilter, onChange, options.handlesOnData);
+                    };
+                    dboTable.sync = sync;
+                    dboTable.syncOne = syncOne;
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    dboTable.useSync = (basicFilter, options) => (0, prostgles_1.useSync)(sync, basicFilter, options);
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    dboTable.useSyncOne = (basicFilter, options) => (0, prostgles_1.useSync)(syncOne, basicFilter, options);
+                }
+                dboTable._sync = async function (param1, param2, syncHandles) {
+                    await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: "_sync", tableName, data: { param1, param2, syncHandles } }));
+                    return syncHandler.addSync({ tableName, command, param1, param2 }, syncHandles);
+                };
+            }
+            else if (sub_commands.includes(command)) {
+                const subFunc = async function (param1 = {}, param2 = {}, onChange, onError) {
+                    await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: command, tableName, data: { param1, param2, onChange, onError } }));
+                    checkSubscriptionArgs(param1, param2, onChange, onError);
+                    return subscriptionHandler.addSub(dbo, { tableName, command, param1, param2 }, onChange, onError);
+                };
+                dboTable[command] = subFunc;
+                const SUBONE = "subscribeOne";
+                /**
+                 * React hooks
+                 */
+                const handlerName = command === "subscribe" ? "useSubscribe" : command === "subscribeOne" ? "useSubscribeOne" : undefined;
+                if (handlerName) {
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    dboTable[handlerName] = (filter, options) => (0, prostgles_1.useSubscribe)(subFunc, command === SUBONE, filter, options);
+                }
+                if (command === SUBONE || !sub_commands.includes(SUBONE)) {
+                    dboTable[SUBONE] = async function (param1, param2, onChange, onError) {
+                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: "getSync", tableName, data: { param1, param2, onChange, onError } }));
+                        checkSubscriptionArgs(param1, param2, onChange, onError);
+                        const onChangeOne = (rows) => { onChange(rows[0]); };
+                        return subscriptionHandler.addSub(dbo, { tableName, command, param1, param2 }, onChangeOne, onError);
+                    };
+                }
+            }
+            else {
+                const method = async function (param1, param2, param3) {
+                    await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "table", command: command, tableName, data: { param1, param2, param3 } }));
+                    return new Promise((resolve, reject) => {
+                        socket.emit(preffix, { tableName, command, param1, param2, param3 }, 
+                        /* Get col definition and re-cast data types?! */
+                        (err, res) => {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(res);
+                        });
+                    });
+                };
+                dboTable[command] = method;
+                const methodName = command === "findOne" ? "useFindOne" : command === "find" ? "useFind" : command === "count" ? "useCount" : command === "size" ? "useSize" : undefined;
+                if (methodName) {
+                    // eslint-disable-next-line react-hooks/rules-of-hooks
+                    dboTable[methodName] = (param1, param2, param3) => (0, prostgles_1.useFetch)(method, [param1, param2, param3]);
+                }
+                if (["find", "findOne"].includes(command)) {
+                    dboTable.getJoinedTables = function () {
+                        return joinTables
+                            .filter(tb => Array.isArray(tb) && tb.includes(tableName))
+                            .flat()
+                            .filter(t => t !== tableName);
+                    };
+                }
+            }
+        });
+    });
+    return { dbo };
+};
+exports.getDBO = getDBO;

package/dist/getMethods.d.ts

@@ -0,0 +1,6 @@
+import type { ClientSchema, MethodHandler } from "prostgles-types";
+import type { InitOptions } from "./prostgles";
+export declare const getMethods: ({ onDebug, methods, socket }: Pick<InitOptions, "onDebug" | "socket"> & Pick<ClientSchema, "methods">) => {
+    methodsObj: MethodHandler;
+};
+//# sourceMappingURL=getMethods.d.ts.map

package/dist/getMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMethods.d.ts","sourceRoot":"","sources":["../lib/getMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,eAAO,MAAM,UAAU,iCAAkC,KAAK,WAAW,EAAE,SAAS,GAAG,QAAQ,CAAC,GAAG,KAAK,YAAY,EAAE,SAAS,CAAC;;CAyB/H,CAAA"}

package/dist/getMethods.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMethods = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const getMethods = ({ onDebug, methods, socket }) => {
+    let methodsObj = {};
+    const _methods = JSON.parse(JSON.stringify(methods));
+    _methods.map(method => {
+        /** New method def */
+        const isBasic = typeof method === "string";
+        const methodName = isBasic ? method : method.name;
+        const onRun = async function (...params) {
+            await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "method", command: methodName, data: { params } }));
+            return new Promise((resolve, reject) => {
+                socket.emit(prostgles_types_1.CHANNELS.METHOD, { method: methodName, params }, (err, res) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(res);
+                });
+            });
+        };
+        methodsObj[methodName] = isBasic ? onRun : {
+            ...method,
+            run: onRun
+        };
+    });
+    methodsObj = Object.freeze(methodsObj);
+    return { methodsObj };
+};
+exports.getMethods = getMethods;

package/dist/getSqlHandler.d.ts

@@ -0,0 +1,6 @@
+import { type SQLHandler } from "prostgles-types";
+import type { InitOptions } from "./prostgles";
+export declare const getSqlHandler: ({ socket }: Pick<InitOptions, "socket">) => {
+    sql: SQLHandler;
+};
+//# sourceMappingURL=getSqlHandler.d.ts.map

package/dist/getSqlHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSqlHandler.d.ts","sourceRoot":"","sources":["../lib/getSqlHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,UAAU,EAAwH,MAAM,iBAAiB,CAAC;AAClL,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,eAAO,MAAM,aAAa,eAAgB,KAAK,WAAW,EAAE,QAAQ,CAAC;;CA0KpE,CAAA"}

package/dist/getSqlHandler.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSqlHandler = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const getSqlHandler = ({ socket }) => {
+    let noticeSubs;
+    const notifSubs = {};
+    const removeNotifListener = (listener, conf, socket) => {
+        const channelSubs = notifSubs[conf.notifChannel];
+        if (channelSubs) {
+            channelSubs.listeners = channelSubs.listeners.filter(nl => nl !== listener);
+            if (!channelSubs.listeners.length && channelSubs.config.socketUnsubChannel && socket) {
+                socket.emit(channelSubs.config.socketUnsubChannel, {});
+                delete notifSubs[conf.notifChannel];
+            }
+        }
+    };
+    const addNotifListener = (listener, conf, socket) => {
+        var _a;
+        const channelSubs = notifSubs[conf.notifChannel];
+        if (!channelSubs) {
+            notifSubs[conf.notifChannel] = {
+                config: conf,
+                listeners: [listener]
+            };
+            socket.removeAllListeners(conf.socketChannel);
+            socket.on(conf.socketChannel, (notif) => {
+                var _a, _b;
+                if ((_a = notifSubs[conf.notifChannel]) === null || _a === void 0 ? void 0 : _a.listeners.length) {
+                    notifSubs[conf.notifChannel].listeners.map(l => {
+                        l(notif);
+                    });
+                }
+                else {
+                    socket.emit((_b = notifSubs[conf.notifChannel]) === null || _b === void 0 ? void 0 : _b.config.socketUnsubChannel, {});
+                }
+            });
+        }
+        else {
+            (_a = notifSubs[conf.notifChannel]) === null || _a === void 0 ? void 0 : _a.listeners.push(listener);
+        }
+    };
+    const removeNoticeListener = (listener, socket) => {
+        if (noticeSubs) {
+            noticeSubs.listeners = noticeSubs.listeners.filter(nl => nl !== listener);
+            if (!noticeSubs.listeners.length && noticeSubs.config.socketUnsubChannel && socket) {
+                socket.emit(noticeSubs.config.socketUnsubChannel, {});
+            }
+        }
+    };
+    const addNoticeListener = (listener, conf, socket) => {
+        noticeSubs !== null && noticeSubs !== void 0 ? noticeSubs : (noticeSubs = {
+            config: conf,
+            listeners: []
+        });
+        if (!noticeSubs.listeners.length) {
+            socket.removeAllListeners(conf.socketChannel);
+            socket.on(conf.socketChannel, (notice) => {
+                if (noticeSubs && noticeSubs.listeners.length) {
+                    noticeSubs.listeners.map(l => {
+                        l(notice);
+                    });
+                }
+                else {
+                    socket.emit(conf.socketUnsubChannel, {});
+                }
+            });
+        }
+        noticeSubs.listeners.push(listener);
+    };
+    const sql = function (query, params, options) {
+        return new Promise((resolve, reject) => {
+            socket.emit(prostgles_types_1.CHANNELS.SQL, { query, params, options }, (err, res) => {
+                if (err) {
+                    return reject(err);
+                }
+                if ((options === null || options === void 0 ? void 0 : options.returnType) === "stream") {
+                    const { channel, unsubChannel } = res;
+                    const start = (listener) => new Promise((resolveStart, rejectStart) => {
+                        socket.on(channel, listener);
+                        socket.emit(channel, {}, (pid, err) => {
+                            if (err) {
+                                rejectStart(err);
+                                socket.removeAllListeners(channel);
+                            }
+                            else {
+                                resolveStart({
+                                    pid,
+                                    run: (query, params) => {
+                                        return new Promise((resolveRun, rejectRun) => {
+                                            socket.emit(channel, { query, params }, (data, _err) => {
+                                                if (_err) {
+                                                    rejectRun(_err);
+                                                }
+                                                else {
+                                                    resolveRun(data);
+                                                }
+                                            });
+                                        });
+                                    },
+                                    stop: (terminate) => {
+                                        return new Promise((resolveStop, rejectStop) => {
+                                            socket.emit(unsubChannel, { terminate }, (data, _err) => {
+                                                if (_err) {
+                                                    rejectStop(_err);
+                                                }
+                                                else {
+                                                    resolveStop(data);
+                                                }
+                                            });
+                                        });
+                                    }
+                                });
+                            }
+                        });
+                    });
+                    const streamHandlers = {
+                        channel,
+                        unsubChannel,
+                        start,
+                    };
+                    return resolve(streamHandlers);
+                }
+                else if (options &&
+                    (options.returnType === "noticeSubscription") &&
+                    res &&
+                    Object.keys(res).sort().join() === ["socketChannel", "socketUnsubChannel"].sort().join() &&
+                    !Object.values(res).find(v => typeof v !== "string")) {
+                    const sockInfo = res;
+                    const addListener = (listener) => {
+                        addNoticeListener(listener, sockInfo, socket);
+                        return {
+                            ...sockInfo,
+                            removeListener: () => removeNoticeListener(listener, socket)
+                        };
+                    };
+                    const handle = {
+                        ...sockInfo,
+                        addListener
+                    };
+                    // @ts-ignore
+                    resolve(handle);
+                }
+                else if ((!options || !options.returnType || options.returnType !== "statement") &&
+                    res &&
+                    Object.keys(res).sort().join() === ["socketChannel", "socketUnsubChannel", "notifChannel"].sort().join() &&
+                    !Object.values(res).find(v => typeof v !== "string")) {
+                    const sockInfo = res;
+                    const addListener = (listener) => {
+                        addNotifListener(listener, sockInfo, socket);
+                        return {
+                            ...res,
+                            removeListener: () => removeNotifListener(listener, sockInfo, socket)
+                        };
+                    };
+                    const handle = { ...res, addListener };
+                    resolve(handle);
+                }
+                else {
+                    resolve(res);
+                }
+            });
+        });
+    };
+    return { sql };
+};
+exports.getSqlHandler = getSqlHandler;