@mgarlik/datastore 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,413 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode } from 'react';
+import * as SQL from 'expo-sqlite';
+
+declare class SQLite$1 {
+    dbName: string;
+    private db;
+    constructor(name?: string);
+    private initDB;
+    private getDb;
+    private createTable;
+    private createTables;
+    /**
+     * Smazani starych logu
+     */
+    private deleteLogs;
+    read<T>(query: string, args?: SQL.SQLiteBindParams): Promise<T[]>;
+    query<T>(query: string, args?: SQL.SQLiteBindParams): Promise<T[]>;
+    dropTable(table: string): Promise<SQL.SQLiteRunResult>;
+    emptyTable(table: string): Promise<SQL.SQLiteRunResult>;
+    getTables(): Promise<unknown[]>;
+    resetDatabase(): Promise<void>;
+}
+
+type ProviderTypes = string;
+type ProviderDataSource = {
+    uri?: string;
+    crud?: {
+        create?: string;
+        read?: string;
+        update?: string;
+        delete?: string;
+        updates?: {
+            [key: string]: string;
+        };
+    };
+    data?: any[];
+    addData?: Record<string, any>[];
+    readAllFields?: boolean;
+    filter?: Record<string, any>;
+    socketListeners?: string[];
+    params?: Record<string, any>;
+    select?: any;
+    file?: string;
+};
+type DataProvider = {
+    id: ProviderTypes;
+    dataSource?: ProviderDataSource;
+    isPermanent?: boolean;
+    isPersisting?: boolean;
+    depend?: string;
+    autoCreate?: boolean;
+    schema?: Record<string, any>;
+    editor?: Record<string, any>;
+    actions?: string[];
+};
+type DataProviders = Record<string, DataProvider>;
+
+type Uuid = string;
+type JSONType = string | number | boolean | {
+    [x: string]: JSONType;
+} | Array<JSONType>;
+type SocketServerType = {
+    url: string;
+    params: Record<string, any>;
+};
+type SocketItem = {
+    listeners: number;
+    data: any[];
+};
+type DispatcherActionType = "registerProvider" | "unregisterProvider" | "updateDataStore" | "createDocument" | "updateDocument" | "updateDocuments" | "removeItem" | "deleteDocument" | "createProviderItem" | "deleteProviderItem";
+type DispatcherType = {
+    isBussy: Boolean;
+    actions: {
+        action: DispatcherActionType;
+        data: any;
+        callback?: (data: JSONType) => void;
+    }[];
+};
+type SchemaTypeItem = {
+    /**
+     * Nazev zdrojoveho pole dat
+     */
+    source?: string;
+    /**
+     * povolene hodnoty
+     */
+    enum?: string[];
+    /**
+     * Je pole vyzadovano ?
+     */
+    required?: boolean;
+    /**
+     * Je pole vyditelne ?
+     */
+    visibility?: "visible" | "hidden";
+    /**
+     * Lze pole editovat ?
+     */
+    editable?: boolean;
+    type?: "string" | "number" | "boolean";
+    form?: "select" | "textInput" | "dateTime" | "radio";
+    mode?: "screen";
+    title?: string;
+    placeholder?: string;
+    description?: string;
+    dataSource?: {
+        dataProvider: string;
+    };
+    itemRules?: string;
+    options?: {
+        dataProvider: string;
+    };
+    validations?: {
+        required?: string;
+        pattern?: JSONType;
+    };
+};
+type SchemaType = {
+    [key: string]: SchemaTypeItem;
+};
+/**
+ * Data Provider Filter
+ */
+type filterItemType = {
+    id: Uuid;
+    priority: number;
+    name: string;
+    value: string;
+    count?: number;
+};
+type FilterType = {
+    id: Uuid;
+    name: string;
+    priority: number;
+    values: Partial<filterItemType>[];
+    type: string;
+};
+/**
+ *
+ */
+type ProductFiltersType = {
+    /** Text input box ? */
+    name?: string;
+    /** Objekt filterovacich parametru {[filterId]: valuesId[]} */
+    filteringParameters: {
+        [key: Uuid]: Uuid[];
+    };
+};
+interface DataStoreProps {
+    providers: DataProviders;
+    /** Adresa REST/CRUD serveru  */
+    restServer: string;
+    socketServer: SocketServerType;
+    /** false - provider nebude cist/ukladat data do persistentniho uloziste */
+    usePersistentStorage?: boolean;
+    children: ReactNode;
+}
+interface DataStore {
+    providers: Record<string, any>;
+    documents: Record<string, any>;
+    updateDocuments: (data: {
+        model: string;
+        documents: any;
+        mode?: "update" | "replace";
+    }) => Promise<void>;
+    dispatch: (action: DispatcherActionType, data: any, callback?: (data: JSONType) => void) => void;
+    initProvider: (id: string, data?: any) => Promise<any>;
+    /** Smaze data providera z databaze */
+    resetProvider: (id: ProviderTypes) => Promise<void>;
+    registerProvider: (provider: DataProvider) => Promise<any>;
+    unregisterProvider: (id: string) => Promise<void>;
+    updateProviderListeners: (id: string, val: number) => Promise<void>;
+    resetDataStore: () => Promise<void>;
+    counterProviders: Record<string, number>;
+    counterDocuments: Record<string, number>;
+    presetProviders: Record<ProviderTypes, DataProvider>;
+    sockets: Record<string, SocketItem>;
+    isLive: boolean;
+    isSynchronizing: boolean;
+    startSockets: () => void;
+    stopSockets: () => void;
+    registerProviderSockets: (sockets: string | string[]) => void;
+    unregisterProviderSockets: (sockets: string | string[]) => void;
+}
+
+declare const SQLite: SQLite$1;
+type DataStoreMetaType = Pick<DataStore, "isLive" | "isSynchronizing" | "sockets" | "counterProviders" | "counterDocuments">;
+type DataStoreActionsType = Pick<DataStore, "dispatch" | "initProvider" | "resetProvider" | "registerProvider" | "unregisterProvider" | "updateProviderListeners" | "resetDataStore" | "startSockets" | "stopSockets" | "registerProviderSockets" | "unregisterProviderSockets" | "updateDocuments" | "presetProviders">;
+type DataStoreStableType = {
+    dispatch: DataStore["dispatch"];
+    presetProviders: DataStore["presetProviders"];
+    updateProviderListeners: DataStore["updateProviderListeners"];
+    subscribeToProvider: (providerId: string, callback: () => void) => () => void;
+    getProviderLastUpdate: (providerId: string) => string | null;
+    getExternalDocuments: () => Record<string, any>;
+    getExternalProviders: () => Record<string, any>;
+};
+/** Meta (isLive, isSynchronizing, sockets, counters) */
+declare const DataStoreContext: React.Context<DataStoreMetaType>;
+/** Raw documents map */
+declare const DataStoreDocumentsContext: React.Context<Record<string, any>>;
+/** Raw providers map */
+declare const DataStoreProvidersContext: React.Context<Record<string, any>>;
+/** Stable action callbacks */
+declare const DataStoreActionsContext: React.Context<DataStoreActionsType>;
+/** Stable datastore API for provider-scoped subscriptions */
+declare const DataStoreStableContext: React.Context<DataStoreStableType>;
+/** Returns all stable action callbacks. Components using this hook never re-render due to document changes. */
+declare const useDataStoreActions: () => DataStoreActionsType;
+/**
+ *
+ * @param filter - objekt filteru
+ * @param resultType - "object"(default) | "array"
+ * @returns {documents, filter}
+ */
+declare const useFilteredDocuments: (filter: Record<string, any>) => {
+    documents: any[] | Record<string, any>;
+    setFilter: React.Dispatch<React.SetStateAction<Record<string, any>>>;
+};
+/**
+ * Vrati objekt vsech dokumentu
+ *
+ * @returns {} documentu
+ */
+declare const useDocuments: () => {
+    [key: string]: any;
+};
+/**
+ * Vrati object of documents daneho providera. Dokumenty lze vyfiltrovat
+ *
+ * @param {*} provider
+ * @param {*} filter
+ * @returns
+ */
+declare const useProviderDocuments: (provider: ProviderTypes, settings?: {
+    filter?: Record<string, any>;
+    documentId?: Uuid;
+    document?: Record<string, any>;
+}) => {
+    [key: string]: any;
+};
+declare const useProvider: (val: ProviderTypes) => any;
+/** Full DataStore — merges all sub-contexts. Components using this re-render on any state change. */
+declare const useDataStore: () => DataStore;
+declare const DataStoreProvider: ({ socketServer, restServer, usePersistentStorage, ...props }: DataStoreProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ *
+ * @param id ID providera z ProviderTypes
+ * @param params parametry pro doplneni URI adresy z dataProviders
+ * @param dataFilter Filter dat providera
+ * @param settings documentId ID dokumentu pouziteho k prepocitani dokumentu providera, document: JSON dokument k prepocitani dokumentu providera
+ * @returns void
+ */
+declare const useDataProvider: (
+/**
+ * Provider id nebo objekt data {key: value}
+ */
+id: ProviderTypes | {
+    [key: string]: any;
+}, 
+/**
+ * Parametry pro prerenderovani providera (profiles/<%= profileId %>)
+ */
+params?: {
+    [key: string]: string;
+} | null, 
+/**
+ * Filtrovani dat
+ */
+dataFilter?: JSONType | null, 
+/**
+ * Nejake nastaveni
+ */
+settings?: {
+    documentId?: string;
+    document?: JSONType;
+}) => {
+    documents: any;
+    schema: any;
+    update: (val: JSONType) => void;
+    updateItem: ({ params, data, variant, documentId }: {
+        params?: JSONType;
+        data?: JSONType;
+        variant?: string;
+        documentId?: string;
+    }, callback?: (resp: JSONType) => void) => void;
+    deleteItem: ({ params, data }: {
+        params?: JSONType;
+        data?: JSONType;
+    }, callback?: (resp: JSONType) => void) => void;
+    createItem: (data: JSONType, callback?: () => void) => void;
+};
+
+/**
+ * blabla
+ */
+interface UseDocumentParams {
+    /**
+     * UUID dokumentu
+     */
+    documentId: Uuid;
+    model?: string;
+    /**
+     * nazev Providera, nebo objekt definice Providera
+     */
+    provider?: string | {};
+    /**
+     * Polozky ktere chceme ziskat. Ty co nejsou ulozene se pokusi stahnout z modelu nebo podle definice Providera a doplnit. Pokud nejsou nastavena zadne polozky, tak vrati to co ma v zarizeni.
+     */
+    fields?: string[];
+    /**
+     * true|false - pozadujeme kompletni dokument.
+     */
+    allFields?: boolean;
+}
+interface UseDocumentResult {
+    /**
+     * Vraci neco
+     */
+    document: Record<string, any>;
+}
+/**
+ * Provider dokumentu z DataProvider
+ *
+ * Example: useDocument({documentId: "123-123123-123123-12", model: "products", fields: ["name", "image"]})
+ *
+ * @param documentId - ID dokumentu
+ * @param model - nazev modelu
+ * @param provider - nazev providera
+ * @param fields - seznam polozek dokumentu ktere chceme ziskat
+ * @param allFields - kompletni dokument
+ *
+ * @returns - vraci dokument
+ */
+declare const useDocument: ({ documentId, model, provider, fields, allFields }: UseDocumentParams) => UseDocumentResult;
+
+declare const useProviderActions: (providerId: Uuid, data?: JSONType) => {
+    schema: any;
+    update: (val: JSONType) => void;
+    updateItem: ({ params, data, variant, documentId }: {
+        params?: JSONType;
+        data?: any;
+        variant?: string;
+        documentId?: Uuid;
+    }, callback?: (value: JSONType) => void) => void;
+    deleteItem: ({ params, data }: {
+        params: JSONType;
+        data?: JSONType;
+    }, callback?: () => void) => void;
+    createItem: (data: JSONType, callback?: (value: JSONType) => void) => void;
+};
+
+declare function recalculateObjectWithDocument(obj: any, document: any): any;
+declare function getValueByRules(data: any, document: any, { mode, ruleId }: {
+    mode?: any;
+    ruleId?: any;
+}): any;
+declare function doesValueMatchFilter(objVal: any, value: any, documents?: any): any;
+declare function doesObjectMatchFilter(obj: any, filter: any, documents?: any): any;
+/**
+ *
+ * Filteruje pole dokumentu podle filteru
+ *
+ * @param {*} documents Pole dokumentu
+ * @param {*} filter object filteru
+ * @returns vraci pole vyfilterovanych dokumentu
+ */
+declare const filterDocuments: <T>(documents: T[] | T, filter: any) => any;
+declare const filterDocumentsAsync: <T>(documents: T[] | T, filter: any) => Promise<any>;
+declare const dataStoreFilterObject: (obj: any, filter: any) => any;
+/**
+ *
+ * @returns UUID v4
+ *
+ * Vygeneruje unikatni UUID v4
+ */
+declare function uuid(): string;
+declare function isUuid(val: string): boolean;
+
+/**
+ * Black: \x1b[30m
+ * Red: \x1b[31m
+ * Green: \x1b[32m
+ *Yellow: \x1b[33m
+ * Blue: \x1b[34m
+ * Magenta: \x1b[35m
+ * Cyan: \x1b[36m
+ * White: \x1b[37m
+ */
+declare const COLOR_WHITE = "\u001B[37m%s\u001B[0m";
+declare const COLOR_MAGENTA = "\u001B[35m%s\u001B[0m";
+declare const COLOR_BLUE = "\u001B[34m%s\u001B[0m";
+declare const COLOR_CYAN = "\u001B[36m%s\u001B[0m";
+declare const COLOR_GREEN = "\u001B[32m%s\u001B[0m";
+declare const COLOR_RED = "\u001B[31m%s\u001B[0m";
+declare const COLOR_ERROR = "\u001B[31m%s\u001B[0m";
+declare const COLOR_YELLOW = "\u001B[33m%s\u001B[0m";
+declare const COLOR_ORANGE = "\u001B[38;5;208m%s\u001B[0m";
+declare const COLOR_WARNING = "\u001B[33m%s\u001B[0m";
+declare const COLOR_PROVIDER = "\u001B[35m%s\u001B[0m";
+declare const COLOR_CONTEXT = "\u001B[35m%s\u001B[0m";
+declare const COLOR_RENDER = "\u001B[34m%s\u001B[0m";
+declare const COLOR_FUNCTION = "\u001B[36m%s\u001B[0m";
+declare const COLOR_SCREEN = "\u001B[32m%s\u001B[0m";
+declare const COLOR_SOCKET = "\u001B[36m%s\u001B[0m";
+declare const COLOR_SOCKETS = "\u001B[33m%s\u001B[0m";
+declare const COLOR_AXIOS = "\u001B[33m%s\u001B[0m";
+declare const COLOR_APP = "\u001B[34m%s\u001B[0m";
+declare const COLOR_DS = "\u001B[35m%s\u001B[0m";
+
+export { COLOR_APP, COLOR_AXIOS, COLOR_BLUE, COLOR_CONTEXT, COLOR_CYAN, COLOR_DS, COLOR_ERROR, COLOR_FUNCTION, COLOR_GREEN, COLOR_MAGENTA, COLOR_ORANGE, COLOR_PROVIDER, COLOR_RED, COLOR_RENDER, COLOR_SCREEN, COLOR_SOCKET, COLOR_SOCKETS, COLOR_WARNING, COLOR_WHITE, COLOR_YELLOW, type DataProvider, type DataProviders, type DataStore, DataStoreActionsContext, DataStoreContext, DataStoreDocumentsContext, type DataStoreProps, DataStoreProvider, DataStoreProvidersContext, DataStoreStableContext, type DispatcherActionType, type DispatcherType, type FilterType, type JSONType, type ProductFiltersType, type ProviderDataSource, type ProviderTypes, SQLite, type SchemaType, type SocketItem, type SocketServerType, type Uuid, dataStoreFilterObject, doesObjectMatchFilter, doesValueMatchFilter, filterDocuments, filterDocumentsAsync, type filterItemType, getValueByRules, isUuid, recalculateObjectWithDocument, useDataProvider, useDataStore, useDataStoreActions, useDocument, useDocuments, useFilteredDocuments, useProvider, useProviderActions, useProviderDocuments, uuid };