@skalfa/skalfa-app-core 1.0.0

package/dist/api.util.d.ts

@@ -0,0 +1,49 @@
+import { AxiosResponse } from "axios";
+export declare const authBearer: (bearer?: string) => string | null;
+export type ApiFilterType = {
+    /** Use filter logic with: "and" / "or". */
+    logic?: "and" | "or";
+    /** Use filter type with: "eq" = Equal, "ne" = Not Equal, "in" = In, "ni" = Not In, "bw" = Between. */
+    type?: "eq" | "ne" | "in" | "ni" | "bw" | "";
+    column?: string;
+    value?: string | number | number[] | string[] | null;
+};
+export type ApiParamsType = {
+    page?: number;
+    paginate?: number;
+    sort?: string[];
+    search?: string;
+    searchable?: string[];
+    selectable?: string[];
+    expand?: string[];
+    selectableOption?: string[];
+    filter?: ApiFilterType[];
+};
+export type ApiType = {
+    path?: string;
+    url?: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    params?: ApiParamsType;
+    payload?: any;
+    includeParams?: Record<string, any>;
+    headers?: Record<string, any>;
+    bearer?: string;
+};
+export declare const ApiFilterValue: {
+    eq: string;
+    ne: string;
+    in: string;
+    ni: string;
+    bw: string;
+};
+export declare const api: ({ path, url, method, params, payload, includeParams, headers, bearer, }: ApiType) => Promise<AxiosResponse<any, any, {}>>;
+export declare const useGetApi: (props: ApiType & {
+    method?: "GET";
+    cacheName?: string;
+    expired?: number;
+}, sleep?: boolean) => {
+    loading: boolean;
+    code: number | null;
+    data: any;
+    reset: () => Promise<"" | undefined>;
+};

package/dist/api.util.js

@@ -0,0 +1,125 @@
+"use client";
+import { useEffect, useState } from "react";
+import axios from "axios";
+import { redirect } from "next/navigation";
+import { auth } from "./auth.util";
+import { cavity } from "./cavity.util";
+// =========================>
+// ## Build auth bearer
+// =========================>
+export const authBearer = (bearer) => {
+    const token = bearer || auth.getAccessToken() || null;
+    return token ? `Bearer ${token}` : null;
+};
+// =========================>
+// ## Api error handler
+// =========================>
+const handleErrors = (fetch) => {
+    if (fetch?.status === 401)
+        redirect(auth.PATH_LOGIN);
+    if (fetch?.status === 403)
+        redirect(auth.PATH_BASE);
+    return fetch;
+};
+// =========================>
+// ## Api filter value
+// =========================>
+export const ApiFilterValue = {
+    eq: "eq",
+    ne: "ne",
+    in: "in",
+    ni: "ni",
+    bw: "bw",
+};
+// =========================>
+// ## Api fetching handler
+// =========================>
+export const api = async ({ path, url, method, params, payload, includeParams, headers, bearer, }) => {
+    const fetchUrl = url || `${process.env.NEXT_PUBLIC_API_HOST}/${path || ""}`;
+    const buildHeaders = { Authorization: authBearer(bearer) || "", ...headers };
+    buildHeaders["Content-Type"] = buildHeaders["Content-Type"] || "multipart/form-data";
+    const filter = {};
+    const jsonParams = {};
+    if (params?.filter) {
+        params?.filter?.map((val) => {
+            filter[val.column] = `${ApiFilterValue[val.type]}:${Array.isArray(val.value) ? val.value.join(",") : val.value}`;
+        });
+    }
+    if (params) {
+        const normalizeToJson = ["sort", "searchable", "selectable", "selectableOption", "expand"];
+        normalizeToJson.forEach((key) => {
+            const k = key;
+            if (Array.isArray(params[k])) {
+                jsonParams[k] = JSON.stringify(params[k]);
+            }
+        });
+    }
+    return await axios(fetchUrl, {
+        method: method || "GET",
+        headers: buildHeaders,
+        data: payload,
+        params: {
+            ...params,
+            ...jsonParams,
+            ...(params?.filter ? { filter: JSON.stringify(filter) } : {}),
+            ...includeParams,
+        },
+    })
+        .then((res) => res)
+        .catch((err) => handleErrors(err.response));
+};
+// =========================>
+// ## Hook of get api 
+// =========================>
+export const useGetApi = (props, sleep) => {
+    const [loading, setLoading] = useState(true);
+    const [code, setCode] = useState(null);
+    const [data, setData] = useState(null);
+    const fetch = async (revalidation = false) => {
+        setLoading(true);
+        // =========================>
+        // ## When cache ready 
+        // =========================>
+        const cacheData = props.expired && !revalidation ? await cavity.get(props.cacheName || `fetch_${props?.path}`) : null;
+        if (cacheData) {
+            setLoading(false);
+            setCode(200);
+            setData(cacheData);
+            return "";
+        }
+        // =========================>
+        // ## Fetch from api
+        // =========================>
+        const response = await api(props);
+        if (response?.status) {
+            setLoading(false);
+            setCode(response?.status);
+            setData(response?.data);
+            // =========================>
+            // ## Save to cache
+            // =========================>
+            if (props.expired)
+                cavity.set({ key: props?.cacheName || `fetch_${props?.path}`, data: response?.data, expired: props.expired });
+        }
+    };
+    useEffect(() => {
+        if (!sleep && (props.path || props.url))
+            fetch();
+    }, [
+        props.path,
+        props.url,
+        props.params?.paginate,
+        props.params?.page,
+        props.params?.search,
+        props.params?.sort,
+        props.params?.filter,
+        props.params?.selectable,
+        props.params?.selectableOption,
+        props.includeParams,
+        props.headers,
+        props.bearer,
+        sleep
+    ]);
+    const reset = () => fetch(true);
+    return { loading, code, data, reset };
+};

package/dist/auth.util.d.ts

@@ -0,0 +1,10 @@
+export declare const auth: {
+    PATH_LOGIN: string;
+    PATH_BASE: string;
+    ACCESS_TOKEN_EXPIRED: number;
+    ACCESS_TOKEN_NAME: string;
+    setAccessToken: (token: string | null, expired?: number) => string | undefined;
+    getAccessToken: () => any;
+    deleteAccessToken: () => void;
+    check: () => false;
+};

package/dist/auth.util.js

@@ -0,0 +1,37 @@
+import { redirect } from 'next/navigation';
+import Cookies from 'js-cookie';
+import { encryption } from './encryption.util';
+export const auth = {
+    // ==============================>
+    // ## Path of login page
+    // ==============================>
+    PATH_LOGIN: '/auth/login',
+    // ==============================>
+    // ## Path of home page
+    // ==============================>
+    PATH_BASE: '/',
+    // ==============================>
+    // ## Access token expired (days)
+    // ==============================>
+    ACCESS_TOKEN_EXPIRED: 7,
+    // ==============================>
+    // ## Name of cookie access token
+    // ==============================>
+    ACCESS_TOKEN_NAME: String(process.env.NEXT_PUBLIC_APP_NAME || '').toLowerCase().trim().replace(/[^\w\s-]/g, '').replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, '') + '.user.token',
+    // ==============================>
+    // ## set access token to cookie
+    // ==============================>
+    setAccessToken: (token, expired) => Cookies.set(auth.ACCESS_TOKEN_NAME, token ? encryption.set(token) : "", { expires: expired || auth.ACCESS_TOKEN_EXPIRED, secure: true }),
+    // ==============================>
+    // ## get access token from cookie
+    // ==============================>
+    getAccessToken: () => encryption.get(Cookies.get(auth.ACCESS_TOKEN_NAME) || ""),
+    // ==============================>
+    // ## delete access token from cookie
+    // ==============================>
+    deleteAccessToken: () => Cookies.remove(auth.ACCESS_TOKEN_NAME),
+    // ==============================>
+    // ## Check auth
+    // ==============================>
+    check: () => (!Cookies.get(auth.ACCESS_TOKEN_NAME)) && redirect(auth.PATH_LOGIN),
+};

package/dist/cavity.util.d.ts

@@ -0,0 +1,20 @@
+type CavityType = {
+    key: string;
+    data: any;
+    expired: number;
+};
+export declare const cavity: {
+    set: ({ key, data, expired }: CavityType) => Promise<() => void>;
+    get: (key: string) => Promise<{
+        message: string;
+        data: Record<string, any>;
+    }>;
+    delete: (key: string) => Promise<() => void>;
+    socket: {
+        register: () => void;
+        subscribe(key: string): void;
+        unsubscribe(key: string): void;
+        invalidate(key: string): void;
+    };
+};
+export {};

package/dist/cavity.util.js

@@ -0,0 +1,124 @@
+import { registry } from "./registry";
+import { logger } from "./commands/logger";
+const name = String(process.env.NEXT_PUBLIC_APP_NAME || "").toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "") + ".cavity";
+const storeName = "cache";
+const version = 1;
+const subscriptions = new Set();
+let registered = false;
+function getSocket() {
+    const s = registry.get("socket");
+    if (s && process.env.NEXT_PUBLIC_SOCKET_URL) {
+        return s.connect();
+    }
+    return null;
+}
+// ==============================>
+// ## Init indexDb
+// ==============================>
+async function idb() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(name, version);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+                db.createObjectStore(storeName, { keyPath: "key" });
+            }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+export const cavity = {
+    // ==============================>
+    // ## Set cache to indexDb
+    // ==============================>
+    set: async ({ key, data, expired }) => {
+        const db = await idb();
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        const item = {
+            key,
+            expired: new Date().getTime() + expired * 60 * 1000,
+            data,
+        };
+        store.put(item);
+        return tx.commit;
+    },
+    // ==============================>
+    // ## Get cache from indexDb
+    // ==============================>
+    get: async (key) => {
+        const db = await idb();
+        const tx = db.transaction(storeName, "readonly");
+        const store = tx.objectStore(storeName);
+        return new Promise((resolve) => {
+            const request = store.get(key);
+            request.onsuccess = () => {
+                const item = request.result;
+                if (!item)
+                    return resolve({ message: "Record not found!", data: [] });
+                if (item.expired > Date.now()) {
+                    resolve(item.data);
+                }
+                else {
+                    const deleteTx = db.transaction(storeName, "readwrite");
+                    deleteTx.objectStore(storeName).delete(key);
+                    resolve({ message: "Record not found!", data: [] });
+                }
+            };
+            request.onerror = () => resolve({ message: "Error!", data: [] });
+        });
+    },
+    // ==============================>
+    // ## Remove cache from indexDb
+    // ==============================>
+    delete: async (key) => {
+        const db = await idb();
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        store.delete(key);
+        return tx.commit;
+    },
+    socket: {
+        register: () => {
+            const socket = getSocket();
+            if (registered || !socket)
+                return;
+            registered = true;
+            socket.on("cache:invalidate", async ({ key }) => {
+                await cavity.delete(key);
+            });
+            socket.on("connect", () => {
+                logger.cavity("WS connected:", socket.id);
+                subscriptions.forEach((key) => cavity.socket.subscribe(key));
+            });
+            socket.on("disconnect", (reason) => {
+                logger.cavityError("WS disconnected:", reason);
+            });
+        },
+        subscribe(key) {
+            const socket = getSocket();
+            if (!socket?.connected)
+                return;
+            if (subscriptions.has(key))
+                return;
+            subscriptions.add(key);
+            socket.emit("cache:subscribe", { key });
+        },
+        unsubscribe(key) {
+            const socket = getSocket();
+            if (!socket?.connected)
+                return;
+            if (!subscriptions.has(key))
+                return;
+            subscriptions.delete(key);
+            socket.emit("cache:unsubscribe", { key });
+        },
+        invalidate(key) {
+            const socket = getSocket();
+            if (!socket?.connected)
+                return;
+            socket.emit("cache:invalidate", { key });
+        },
+    }
+};

package/dist/cn.util.d.ts

@@ -0,0 +1,3 @@
+import { ClassValue } from "clsx";
+export declare const cn: (...classes: ClassValue[]) => string;
+export declare const pcn: <prefixType>(className: string, prefix: prefixType, pseudoClass?: string) => string;

package/dist/cn.util.js

@@ -0,0 +1,45 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+// ==============================>
+// ## Merge class name
+// ==============================>
+export const cn = (...classes) => twMerge(clsx(classes));
+// ==============================>
+// ## Parse class name with custom prefix
+// ==============================>
+export const pcn = (className, prefix, pseudoClass) => {
+    const classes = className.split(" ");
+    const matchedClasses = classes.filter((cls) => {
+        const [clsPrefix, ...rest] = cls.split("::");
+        if (rest.length === 0 && (prefix === "input" || prefix === "base"))
+            return true;
+        if (rest.length > 0 && clsPrefix === prefix) {
+            if (pseudoClass) {
+                const [pseudo] = rest.join("::").split(":");
+                return pseudo === pseudoClass;
+            }
+            return true;
+        }
+        return false;
+    }).map((cls) => {
+        const [clsPrefix, ...rest] = cls.split("::");
+        if (rest.length > 0 && clsPrefix === prefix) {
+            const classNameWithoutPrefix = rest.join("::");
+            if (pseudoClass) {
+                return classNameWithoutPrefix.split(":").slice(1).join(":");
+            }
+            else {
+                if (/^(?!.*\b\w+:).*$/.test(classNameWithoutPrefix)) {
+                    return classNameWithoutPrefix;
+                }
+                else {
+                    return "";
+                }
+            }
+        }
+        if (rest.length === 0 && (prefix === "input" || prefix === "base"))
+            return cls;
+        return "";
+    }).filter(Boolean);
+    return matchedClasses.join(" ");
+};

package/dist/commands/barrels.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/barrels.js

@@ -0,0 +1,22 @@
+import path from "path";
+import fs from "fs";
+import { exec } from "child_process";
+import { logger } from "./logger";
+const rootDir = path.resolve();
+const configText = fs.readFileSync("barrels.json", "utf8");
+const config = JSON.parse(configText);
+const directories = Array.isArray(config.directory) ? config.directory : [config.directory];
+directories.forEach((dir) => {
+    const absoluteDir = path.join(rootDir, dir);
+    if (!fs.existsSync(absoluteDir)) {
+        logger.error(`Barrels error: ${absoluteDir} directory not found`);
+        return;
+    }
+    fs.watch(absoluteDir, { recursive: true }, (_, filename) => {
+        if (filename && (filename.endsWith(".ts") || filename.endsWith(".tsx")) && filename !== "index.ts") {
+            exec("npx barrelsby -c barrels.json", { cwd: rootDir });
+            logger.info("Barrels updated " + absoluteDir + "/index.ts");
+        }
+    });
+});
+logger.start("Barrels watched " + directories.join(", "));

package/dist/commands/blueprint.d.ts

@@ -0,0 +1,3 @@
+export declare function blueprint(options?: {
+    only?: string[];
+}): Promise<void>;