@addev-be/ui 0.20.1 → 0.20.2

package/dist/providers/index.js

@@ -17,5 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AuthenticationProvider"), exports);
 __exportStar(require("./PortalsProvider"), exports);
 __exportStar(require("./ThemeProvider"), exports);
+__exportStar(require("./TrackingProvider"), exports);
 __exportStar(require("./UiProviders"), exports);
+__exportStar(require("./TrackingProvider/hooks"), exports);
 __exportStar(require("./hooks"), exports);

package/dist/services/WebSocketService.d.ts

@@ -1,11 +1,19 @@
 import { Config } from '../config';
 import { Subject } from 'rxjs';
+export declare class WebSocketError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
 export declare class WebSocketService {
     private static instance;
     private config;
     private socket;
     status: boolean | undefined;
     status$: Subject<boolean | undefined>;
+    error$: Subject<{
+        status: number;
+        message: string;
+    }>;
     private queue;
     private promises;
     onOpen?: () => void;

package/dist/services/WebSocketService.js

@@ -1,13 +1,40 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketService = void 0;
+exports.WebSocketService = exports.WebSocketError = void 0;
 var rxjs_1 = require("rxjs");
 var uuid_1 = require("uuid");
+var WebSocketError = /** @class */ (function (_super) {
+    __extends(WebSocketError, _super);
+    function WebSocketError(status, message) {
+        var _this = _super.call(this, message) || this;
+        _this.status = status;
+        _this.name = 'WebSocketError';
+        return _this;
+    }
+    return WebSocketError;
+}(Error));
+exports.WebSocketError = WebSocketError;
 var WebSocketService = /** @class */ (function () {
     function WebSocketService(config) {
         this.socket = null;
         this.status = undefined;
         this.status$ = new rxjs_1.Subject();
+        this.error$ = new rxjs_1.Subject();
         this.queue = [];
         this.promises = {};
         this.onOpen = function () { };
@@ -84,6 +111,7 @@ var WebSocketService = /** @class */ (function () {
             var request = { id: id, name: name, data: data };
             _this.promises[id] = { resolve: resolve, reject: reject };
             if (!_this.socket || !_this.status) {
+                console.log('[WS] Queuing request:', request);
                 _this.queue.push(request);
                 return;
             }
@@ -103,7 +131,11 @@ var WebSocketService = /** @class */ (function () {
                 console.log('[WS] Received response:', response);
                 if (typeof ((_a = response.data) === null || _a === void 0 ? void 0 : _a.status) === 'number' &&
                     response.data.status < 0) {
-                    this.promises[response.id].reject(new Error(response.data.message));
+                    this.promises[response.id].reject(new WebSocketError(response.data.status, response.data.message));
+                    this.error$.next({
+                        status: response.data.status,
+                        message: response.data.message || 'Unknown error',
+                    });
                 }
                 else {
                     this.promises[response.id].resolve(response.data);

package/dist/services/globalSearch.d.ts

@@ -1,6 +1,10 @@
-import { SqlRequestRow } from './sqlRequests';
+import { ConditionDTO, SqlRequestRow } from './sqlRequests';
+import { OrderByDTO } from './sqlRequests';
 export type GlobalSearchRequestDTO = {
-    types: string[];
+    types: Record<string, {
+        conditions?: ConditionDTO[];
+        orderBy?: OrderByDTO[];
+    }>;
     searchTerm: string;
     limit?: number;
 };

package/dist/services/hooks.d.ts

@@ -1,3 +1,13 @@
 export declare const useLoadingRequestHandler: <TReq, TRes>(name: string) => ((data: TReq) => Promise<TRes>);
 export declare const useWebSocketRequestHandler: <TReq, TRes>(name: string) => ((data: TReq) => Promise<TRes>);
 export declare const useHttpRequestHandler: <TReq, TRes>(name: string) => ((data: TReq, files?: Record<string, File>) => Promise<TRes>);
+export declare const useRequestState: <TReq, TRes>(name: string, loading?: boolean) => {
+    status: number | undefined;
+    isInitial: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    response: TRes | null;
+    sendRequest: (data: TReq) => Promise<TRes | undefined>;
+    reset: () => void;
+};

package/dist/services/hooks.js

@@ -1,9 +1,45 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHttpRequestHandler = exports.useWebSocketRequestHandler = exports.useLoadingRequestHandler = void 0;
-var HttpService_1 = require("./HttpService");
+exports.useRequestState = exports.useHttpRequestHandler = exports.useWebSocketRequestHandler = exports.useLoadingRequestHandler = void 0;
 var WebSocketService_1 = require("./WebSocketService");
 var react_1 = require("react");
+var HttpService_1 = require("./HttpService");
 var providers_1 = require("../providers");
 var useLoadingRequestHandler = function (name) {
     var _a = (0, providers_1.useLoading)(), startLoading = _a.startLoading, stopLoading = _a.stopLoading;
@@ -27,3 +63,54 @@ var useHttpRequestHandler = function (name) {
     }, [name]);
 };
 exports.useHttpRequestHandler = useHttpRequestHandler;
+var useRequestState = function (name, loading) {
+    if (loading === void 0) { loading = false; }
+    var _a = (0, react_1.useState)('initial'), state = _a[0], setState = _a[1];
+    var _b = (0, react_1.useState)(undefined), status = _b[0], setStatus = _b[1];
+    var _c = (0, react_1.useState)(null), response = _c[0], setResponse = _c[1];
+    var handleSendRequest = (0, exports.useWebSocketRequestHandler)(name);
+    var handleSendLoadingRequest = (0, exports.useLoadingRequestHandler)(name);
+    var sendRequest = (0, react_1.useCallback)(function (data) { return __awaiter(void 0, void 0, void 0, function () {
+        var res, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setState('loading');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, (loading
+                            ? handleSendLoadingRequest
+                            : handleSendRequest)(data)];
+                case 2:
+                    res = _a.sent();
+                    setStatus(0);
+                    setResponse(res);
+                    setState('success');
+                    return [2 /*return*/, res];
+                case 3:
+                    error_1 = _a.sent();
+                    setStatus(error_1 instanceof WebSocketService_1.WebSocketError ? error_1.status : -1);
+                    setState('error');
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }, [handleSendLoadingRequest, handleSendRequest, loading]);
+    var reset = (0, react_1.useCallback)(function () {
+        setState('initial');
+        setStatus(undefined);
+        setResponse(null);
+    }, []);
+    return {
+        status: status,
+        isInitial: state === 'initial',
+        isLoading: state === 'loading',
+        isSuccess: state === 'success',
+        isError: state === 'error',
+        response: response,
+        sendRequest: sendRequest,
+        reset: reset,
+    };
+};
+exports.useRequestState = useRequestState;

package/dist/services/index.d.ts

@@ -3,9 +3,16 @@ export * from './HttpService';
 export * from './hooks';
 export * from './globalSearch';
 export * from './requests/auth';
+export * from './requests/generic';
+export * from './requests/tracking';
 export * from './requests/users';
 export * from './requests/userProfiles';
 export * from './types/auth';
 export * from './types/base';
+export * from './types/generic';
+export * from './types/tracking';
 export * from './types/users';
 export * from './types/userProfiles';
+export * from './sqlRequests';
+export * from './updateSqlRequests';
+export * as SmartQueries from './smartQueries';

package/dist/services/index.js

@@ -10,18 +10,38 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartQueries = void 0;
 __exportStar(require("./WebSocketService"), exports);
 __exportStar(require("./HttpService"), exports);
 __exportStar(require("./hooks"), exports);
 __exportStar(require("./globalSearch"), exports);
 __exportStar(require("./requests/auth"), exports);
+__exportStar(require("./requests/generic"), exports);
+__exportStar(require("./requests/tracking"), exports);
 __exportStar(require("./requests/users"), exports);
 __exportStar(require("./requests/userProfiles"), exports);
 __exportStar(require("./types/auth"), exports);
 __exportStar(require("./types/base"), exports);
+__exportStar(require("./types/generic"), exports);
+__exportStar(require("./types/tracking"), exports);
 __exportStar(require("./types/users"), exports);
 __exportStar(require("./types/userProfiles"), exports);
+__exportStar(require("./sqlRequests"), exports);
+__exportStar(require("./updateSqlRequests"), exports);
+exports.SmartQueries = __importStar(require("./smartQueries"));

package/dist/services/requests/generic.d.ts

@@ -0,0 +1,29 @@
+import * as t from 'io-ts';
+export declare const useGenericGetRequestHandler: <C extends t.Mixed>(name: string, codec: C) => (data: {
+    id: string;
+}) => Promise<{
+    status: number;
+    data: t.TypeOf<C>;
+}>;
+export declare const useGenericGetAllRequestHandler: <C extends t.Mixed>(name: string, codec: C) => (data: {}) => Promise<{
+    status: number;
+    data: t.TypeOf<C>[];
+}>;
+export declare const useGenericSaveRequestHandler: <C extends t.Mixed>(name: string, codec: C) => (data: {
+    data: t.TypeOf<C>;
+}) => Promise<{
+    status: number;
+    data: t.TypeOf<C>;
+}>;
+export declare const useGenericDeleteRequestHandler: (name: string) => (data: {
+    ids: string[];
+}) => Promise<{
+    status: number[];
+}>;
+export declare const useGenericArchiveRequestHandler: (name: string) => (data: {
+    ids: string[];
+} & {
+    archived?: boolean | undefined;
+}) => Promise<{
+    status: number[];
+}>;

package/dist/services/requests/generic.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGenericArchiveRequestHandler = exports.useGenericDeleteRequestHandler = exports.useGenericSaveRequestHandler = exports.useGenericGetAllRequestHandler = exports.useGenericGetRequestHandler = void 0;
+var generic_1 = require("../types/generic");
+var hooks_1 = require("../hooks");
+var useGenericGetRequestHandler = function (name, codec) {
+    var responseCodec = (0, generic_1.getGenericGetResponseDtoCodec)(codec);
+    return (0, hooks_1.useLoadingRequestHandler)(name);
+};
+exports.useGenericGetRequestHandler = useGenericGetRequestHandler;
+var useGenericGetAllRequestHandler = function (name, codec) {
+    var responseCodec = (0, generic_1.getGenericGetAllResponseDtoCodec)(codec);
+    return (0, hooks_1.useLoadingRequestHandler)(name);
+};
+exports.useGenericGetAllRequestHandler = useGenericGetAllRequestHandler;
+var useGenericSaveRequestHandler = function (name, codec) {
+    var requestCodec = (0, generic_1.getGenericSaveRequestDtoCodec)(codec);
+    var responseCodec = (0, generic_1.getGenericSaveResponseDtoCodec)(codec);
+    return (0, hooks_1.useLoadingRequestHandler)(name);
+};
+exports.useGenericSaveRequestHandler = useGenericSaveRequestHandler;
+var useGenericDeleteRequestHandler = function (name) {
+    return (0, hooks_1.useLoadingRequestHandler)(name);
+};
+exports.useGenericDeleteRequestHandler = useGenericDeleteRequestHandler;
+var useGenericArchiveRequestHandler = function (name) {
+    return (0, hooks_1.useLoadingRequestHandler)(name);
+};
+exports.useGenericArchiveRequestHandler = useGenericArchiveRequestHandler;

package/dist/services/requests/tracking.d.ts

@@ -0,0 +1,18 @@
+export declare const useSendTrackingEventRequestHandler: () => (data: {
+    data: {
+        name: string;
+        details: {
+            [x: string]: string | number | boolean | null;
+        };
+        id: string | null;
+    };
+}) => Promise<{
+    status: number;
+    data: {
+        name: string;
+        details: {
+            [x: string]: string | number | boolean | null;
+        };
+        id: string | null;
+    };
+}>;

package/dist/services/requests/tracking.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSendTrackingEventRequestHandler = void 0;
+var hooks_1 = require("../hooks");
+var useSendTrackingEventRequestHandler = function () {
+    return (0, hooks_1.useLoadingRequestHandler)('SendTrackingEvent');
+};
+exports.useSendTrackingEventRequestHandler = useSendTrackingEventRequestHandler;

package/dist/services/smartQueries.d.ts

@@ -0,0 +1,51 @@
+export type FieldDTO<T extends string = string> = {
+    fieldName?: T;
+    fieldAlias?: string;
+    operator?: 'add' | 'avg' | 'concat' | 'count' | 'divide' | 'groupConcat' | 'if' | 'ifNull' | 'jsonObject' | 'length' | 'max' | 'min' | 'modulo' | 'multiply' | 'subtract' | 'sum' | 'trim';
+    operands?: FieldDTO[];
+    constantValue?: string | number | boolean | null;
+    groupBy?: boolean;
+};
+export type ConditionOperator = 'lessThan' | 'lessThanOrEqual' | 'lessThanOrEquals' | 'equals' | 'notEquals' | 'greaterThanOrEqual' | 'greaterThanOrEquals' | 'greaterThan' | 'like' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'notLike' | 'inRange' | 'between' | 'isNull' | 'isNotNull' | 'inArray' | 'in' | 'not' | 'and' | 'or';
+export type HavingDTO = {
+    operator: ConditionOperator;
+    value?: string | number | boolean | null | (string | number | boolean | null)[];
+};
+export type ConditionDTO = HavingDTO & {
+    field: string | FieldDTO;
+    children?: boolean;
+};
+export type OrderByDirection = 'ascending' | 'descending';
+export type FooterFunction = 'sum' | 'avg' | 'count' | 'max' | 'min';
+export type ColumnDTO = {
+    key: string;
+    field: FieldDTO;
+    having?: HavingDTO;
+    orderBy?: OrderByDirection;
+    groupBy?: boolean;
+    footer?: FooterFunction;
+};
+export type ColumnWithHavingDTO = ColumnDTO & Required<Pick<ColumnDTO, 'having'>>;
+export type ColumnWithFooterDTO = ColumnDTO & Required<Pick<ColumnDTO, 'footer'>>;
+export type QueryDTO = {
+    type: string;
+    columns?: ColumnDTO[];
+    filterColumn?: ColumnDTO;
+    where?: ConditionDTO[];
+    offset?: number;
+    limit?: number;
+    getCount?: boolean;
+    unique?: boolean;
+};
+export type RequestRow<R> = {
+    [K in keyof R]: R[K] extends string | number | null | undefined ? R[K] : string | number | null | undefined;
+};
+export type ResponseDTO<T = unknown> = {
+    data: RequestRow<T>[];
+    count?: number;
+    totals?: Record<string, string | number | null | undefined>;
+};
+export type RequestHandler<T> = (request: QueryDTO) => Promise<ResponseDTO<T>>;
+export declare const useSmartQueryHandler: <T = unknown>(name: string) => [RequestHandler<T>, RequestHandler<{
+    id: string;
+}>, RequestHandler<Partial<T>>];

package/dist/services/smartQueries.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSmartQueryHandler = void 0;
+var hooks_1 = require("./hooks");
+var useSmartQueryHandler = function (name) { return [
+    (0, hooks_1.useWebSocketRequestHandler)(name),
+    (0, hooks_1.useWebSocketRequestHandler)(name),
+    (0, hooks_1.useWebSocketRequestHandler)(name),
+]; };
+exports.useSmartQueryHandler = useSmartQueryHandler;

package/dist/services/smartRequests.js

@@ -0,0 +1 @@
+"use strict";

package/dist/services/types/generic.d.ts

@@ -0,0 +1,44 @@
+import * as t from 'io-ts';
+export declare const genericGetRequestDtoCodec: t.TypeC<{
+    id: t.StringC;
+}>;
+export declare const getGenericGetResponseDtoCodec: <C extends t.Mixed>(codec: C) => t.TypeC<{
+    status: t.NumberC;
+    data: C;
+}>;
+export type GenericGetRequestDTO = t.TypeOf<typeof genericGetRequestDtoCodec>;
+/*****/
+export declare const genericGetAllRequestDtoCodec: t.TypeC<{}>;
+export declare const getGenericGetAllResponseDtoCodec: <C extends t.Mixed>(codec: C) => t.TypeC<{
+    status: t.NumberC;
+    data: t.ArrayC<C>;
+}>;
+export type GenericGetAllRequestDTO = t.TypeOf<typeof genericGetAllRequestDtoCodec>;
+/*****/
+export declare const getGenericSaveRequestDtoCodec: <C extends t.Mixed>(codec: C) => t.TypeC<{
+    data: C;
+}>;
+export declare const getGenericSaveResponseDtoCodec: <C extends t.Mixed>(codec: C) => t.TypeC<{
+    status: t.NumberC;
+    data: C;
+}>;
+/*****/
+export declare const genericArchiveRequestDtoCodec: t.IntersectionC<[t.TypeC<{
+    ids: t.ArrayC<t.StringC>;
+}>, t.PartialC<{
+    archived: t.BooleanC;
+}>]>;
+export declare const genericArchiveResponseDtoCodec: t.TypeC<{
+    status: t.ArrayC<t.NumberC>;
+}>;
+export type GenericArchiveRequestDTO = t.TypeOf<typeof genericArchiveRequestDtoCodec>;
+export type GenericArchiveResponseDTO = t.TypeOf<typeof genericArchiveResponseDtoCodec>;
+/*****/
+export declare const genericDeleteRequestDtoCodec: t.TypeC<{
+    ids: t.ArrayC<t.StringC>;
+}>;
+export declare const genericDeleteResponseDtoCodec: t.TypeC<{
+    status: t.ArrayC<t.NumberC>;
+}>;
+export type GenericDeleteRequestDTO = t.TypeOf<typeof genericDeleteRequestDtoCodec>;
+export type GenericDeleteResponseDTO = t.TypeOf<typeof genericDeleteResponseDtoCodec>;

package/dist/services/types/generic.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericDeleteResponseDtoCodec = exports.genericDeleteRequestDtoCodec = exports.genericArchiveResponseDtoCodec = exports.genericArchiveRequestDtoCodec = exports.getGenericSaveResponseDtoCodec = exports.getGenericSaveRequestDtoCodec = exports.getGenericGetAllResponseDtoCodec = exports.genericGetAllRequestDtoCodec = exports.getGenericGetResponseDtoCodec = exports.genericGetRequestDtoCodec = void 0;
+var t = __importStar(require("io-ts"));
+exports.genericGetRequestDtoCodec = t.type({
+    id: t.string,
+}, 'GenericGetRequestDTO');
+var getGenericGetResponseDtoCodec = function (codec) {
+    return t.type({
+        status: t.number,
+        data: codec,
+    });
+};
+exports.getGenericGetResponseDtoCodec = getGenericGetResponseDtoCodec;
+/*****/
+exports.genericGetAllRequestDtoCodec = t.type({}, 'GenericGetAllRequestDTO');
+var getGenericGetAllResponseDtoCodec = function (codec) {
+    return t.type({
+        status: t.number,
+        data: t.array(codec),
+    });
+};
+exports.getGenericGetAllResponseDtoCodec = getGenericGetAllResponseDtoCodec;
+/*****/
+var getGenericSaveRequestDtoCodec = function (codec) {
+    return t.type({
+        data: codec,
+    });
+};
+exports.getGenericSaveRequestDtoCodec = getGenericSaveRequestDtoCodec;
+var getGenericSaveResponseDtoCodec = function (codec) {
+    return t.type({
+        status: t.number,
+        data: codec,
+    });
+};
+exports.getGenericSaveResponseDtoCodec = getGenericSaveResponseDtoCodec;
+/*****/
+exports.genericArchiveRequestDtoCodec = t.intersection([
+    t.type({
+        ids: t.array(t.string),
+    }),
+    t.partial({
+        archived: t.boolean,
+    }),
+], 'GenericArchiveRequestDTO');
+exports.genericArchiveResponseDtoCodec = t.type({
+    status: t.array(t.number),
+}, 'GenericArchiveResponseDTO');
+/*****/
+exports.genericDeleteRequestDtoCodec = t.type({
+    ids: t.array(t.string),
+}, 'GenericDeleteRequestDTO');
+exports.genericDeleteResponseDtoCodec = t.type({
+    status: t.array(t.number),
+}, 'GenericDeleteResponseDTO');

package/dist/services/types/tracking.d.ts

@@ -0,0 +1,24 @@
+import * as t from 'io-ts';
+export declare const trackingEventDtoCodec: t.TypeC<{
+    name: t.StringC;
+    details: t.RecordC<t.StringC, t.UnionC<[t.StringC, t.NumberC, t.BooleanC, t.NullC]>>;
+    id: t.UnionC<[t.StringC, t.NullC]>;
+}>;
+export type TrackingEventDTO = t.TypeOf<typeof trackingEventDtoCodec>;
+export declare const sendTrackingEventRequestDtoCodec: t.TypeC<{
+    data: t.TypeC<{
+        name: t.StringC;
+        details: t.RecordC<t.StringC, t.UnionC<[t.StringC, t.NumberC, t.BooleanC, t.NullC]>>;
+        id: t.UnionC<[t.StringC, t.NullC]>;
+    }>;
+}>;
+export declare const sendTrackingEventResponseDtoCodec: t.TypeC<{
+    status: t.NumberC;
+    data: t.TypeC<{
+        name: t.StringC;
+        details: t.RecordC<t.StringC, t.UnionC<[t.StringC, t.NumberC, t.BooleanC, t.NullC]>>;
+        id: t.UnionC<[t.StringC, t.NullC]>;
+    }>;
+}>;
+export type SendTrackingEventRequestDTO = t.TypeOf<typeof sendTrackingEventRequestDtoCodec>;
+export type SendTrackingEventResponseDTO = t.TypeOf<typeof sendTrackingEventResponseDtoCodec>;

package/dist/services/types/tracking.js

@@ -0,0 +1,47 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTrackingEventResponseDtoCodec = exports.sendTrackingEventRequestDtoCodec = exports.trackingEventDtoCodec = void 0;
+var t = __importStar(require("io-ts"));
+var base_1 = require("./base");
+exports.trackingEventDtoCodec = t.type(__assign(__assign({}, base_1.baseModelDtoCodec.props), { name: t.string, details: t.record(t.string, t.union([t.string, t.number, t.boolean, t.null])) }), 'TrackingEventDTO');
+exports.sendTrackingEventRequestDtoCodec = t.type({
+    data: exports.trackingEventDtoCodec,
+}, 'SendTrackingEventRequestDTO');
+exports.sendTrackingEventResponseDtoCodec = t.type({
+    status: t.number,
+    data: exports.trackingEventDtoCodec,
+}, 'SendTrackingEventResponseDTO');

package/dist/services/updateSqlRequests.d.ts

@@ -0,0 +1,24 @@
+export type UpdateSqlRequestDTO = {
+    type: string;
+    added: {
+        [id: string]: {
+            [field: string]: string | number | boolean | null | undefined;
+        };
+    };
+    updated: {
+        [id: string]: {
+            [field: string]: string | number | boolean | null | undefined;
+        };
+    };
+};
+export type UpdateSqlResponseDTO = {
+    results: {
+        [id: string]: {
+            status: number;
+            error?: string;
+        };
+    };
+};
+type UpdateSqlRequestHandler = (request: UpdateSqlRequestDTO) => Promise<UpdateSqlResponseDTO>;
+export declare const useUpdateSqlRequestHandler: (name: string) => UpdateSqlRequestHandler;
+export {};