storemw-core-api 1.0.0

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+declare const app: import("express-serve-static-core").Express;
+export default app;

package/dist/app.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const configs_1 = require("./configs");
+// import { salesRoutes } from "./routes/sales"
+// import { toolsRoutes } from "./routes/bk_tools"
+// import { memberRoutes } from "./routes/member"
+// import { documentRoutes, repositoryRoutes } from "./routes/unuse/document"
+const routes_1 = require("./routes");
+const request_1 = require("./middlewares/request");
+// import { logger } from "./utils"
+const app = (0, express_1.default)();
+const PORT = configs_1.config.PORT;
+const NODE_ENV = configs_1.config.NODE_ENV;
+// Enable CORS for all origins
+app.use(request_1.validateCors);
+// Register global check headers handler
+app.use(request_1.validateHeader);
+// Middleware
+// app.use(express.json());
+app.use(express_1.default.json({ limit: '15mb' }));
+app.use(express_1.default.urlencoded({ limit: '15mb', extended: true }));
+// Initial Prisma
+app.use(request_1.initialPrisma);
+// Public Routes
+// app.use("/api/tools", toolsRoutes);
+// Protected Routes
+// app.use(validateAuthorization); // Validate the Authorization
+// app.use(validateSignature); // Validate the Signature
+// app.use(authenticateSmw); // Authenticate with SMW Server
+app.use(["/auth"], routes_1.authRoutes);
+app.use(["/user"], routes_1.userRoutes);
+app.use(["/users"], routes_1.usersRoutes);
+app.use(["/item"], routes_1.itemRoutes);
+app.use(["/items"], routes_1.itemsRoutes);
+app.use(["/region"], routes_1.regionRoutes);
+app.use(["/regions"], routes_1.regionsRoutes);
+app.use(["/location"], routes_1.locationRoutes);
+app.use(["/locations"], routes_1.locationsRoutes);
+app.use(["/injection_field"], routes_1.injectionFieldRoutes);
+app.use(["/injection_fields"], routes_1.injectionFieldsRoutes);
+// app.use(errorHandler); // Register global error handler
+exports.default = app;

package/dist/configs/config.d.ts

@@ -0,0 +1,7 @@
+export declare const config: {
+    NODE_ENV: string;
+    PORT: string | number;
+    JWT_SECRET: string;
+    SUPABASE_PROJECT_URL: string;
+    SUPABASE_API_KEY: string;
+};

package/dist/configs/config.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+// Determine the environment (default to "development")
+const env = process.env.NODE_ENV || "development";
+// Load the corresponding .env file
+dotenv_1.default.config({ path: path_1.default.resolve(__dirname, `${env}.env`) });
+exports.config = {
+    NODE_ENV: env,
+    PORT: process.env.PORT || 8080,
+    // API_KEY: process.env.API_KEY || "",
+    // BASIC_AUTH_USERNAME: process.env.BASIC_AUTH_USERNAME || "",
+    // BASIC_AUTH_PASSWORD: process.env.BASIC_AUTH_PASSWORD || "",
+    // SMW_API_ENDPOINT: process.env.SMW_API_ENDPOINT || "",
+    // SMW_AUTH_USERNAME: process.env.SMW_AUTH_USERNAME || "",
+    // SMW_AUTH_PASSWORD: process.env.SMW_AUTH_PASSWORD || "",
+    JWT_SECRET: process.env.JWT_SECRET || "",
+    SUPABASE_PROJECT_URL: process.env.SUPABASE_PROJECT_URL || "",
+    SUPABASE_API_KEY: process.env.SUPABASE_API_KEY || "",
+    // DB_USER: process.env.DB_USER || "",
+    // DB_HOST: process.env.DB_HOST || "",
+    // DB_NAME: process.env.DB_NAME || "",
+    // DB_PASSWORD: process.env.DB_PASSWORD || "",
+    // DB_PORT: process.env.DB_PORT || ""
+};

package/dist/configs/index.d.ts

@@ -0,0 +1 @@
+export { config } from "../configs/config";

package/dist/configs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+var config_1 = require("../configs/config");
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_1.config; } });

package/dist/configs/production.env

@@ -0,0 +1,6 @@
+PORT=8080
+NODE_ENV=production
+
+## DB ##
+SUPABASE_PROJECT_URL=https://gmrcmwnuhmszkqfdfepx.supabase.co
+SUPABASE_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImdtcmNtd251aG1zemtxZmRmZXB4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTU1MDUwNzMsImV4cCI6MjA3MTA4MTA3M30.vB4HkgBxqubg3Y3SY2irMB3cyeALdt9fa_JnQJ95FDo

package/dist/controllers/auth/authController.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response } from "express";
+/** auth/token : get auth token */
+export declare function getAuthToken(req: Request, res: Response): Promise<any>;

package/dist/controllers/auth/authController.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthToken = getAuthToken;
+const configs_1 = require("../../configs");
+const utils_1 = require("../../utils");
+const services_1 = require("../../services");
+const payload_1 = require("../../schema/payload");
+// import { QueryList } from "../../schema/middleware/route";
+// const getRootName = (requestUserType: UserServiceProps["userType"], toSingular: boolean) => {
+//     let rootName: any = ``
+//     switch (requestUserType) {
+//         case "administrator": rootName = toSingular ? "administrator" : "administrators"; break;
+//         case "customer": rootName = toSingular ? "customer" : "customers"; break;
+//         case "worker": rootName = toSingular ? "worker" : "workers"; break;
+//     }
+//     return rootName
+// }
+/** auth/token : get auth token */
+async function getAuthToken(req, res) {
+    try {
+        const requestAuthType = req.body.scope.target;
+        const jwtSecretKey = configs_1.config.JWT_SECRET;
+        const authService = (0, services_1.AuthService)({
+            ...(0, utils_1.getDefaultServiceProps)(req),
+            secretKey: jwtSecretKey,
+            authType: requestAuthType
+        });
+        let reqScope = req.body.scope;
+        let reqPayload = req.body.payload;
+        let request = payload_1.schemaAuthTokenPayload.parse({
+            scope: {
+                target: reqScope.target,
+                action: reqScope.action
+            },
+            payload: {
+                username: reqPayload.username,
+                password: reqPayload.username
+            }
+        });
+        let payload = {
+            authType: requestAuthType,
+            data: {
+                username: request.payload.username,
+                password: request.payload.password
+            }
+        };
+        const data = await authService.getAuthToken(payload);
+        return (0, utils_1.sendSuccess)(res, data, "Token Retrieved successfully", ``);
+    }
+    catch (error) {
+        (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", `Error: ${error?.message}`, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    }
+}

package/dist/controllers/index.d.ts

@@ -0,0 +1,6 @@
+export { getAuthToken } from '../controllers/auth/authController';
+export { createUser, updateUser, getUser, listUsers, deleteUsers, getUserDataTypes } from '../controllers/user/userController';
+export { createRegion, updateRegion, getRegion, listRegions, deleteRegions, getRegionDataTypes } from '../controllers/region/regionController';
+export { createLocation, updateLocation, getLocation, listLocations, deleteLocations, getLocationDataTypes } from '../controllers/location/locationController';
+export { createItem, updateItem, getItem, listItems, deleteItems, getItemDataTypes } from '../controllers/item/itemController';
+export { listInjectionFields, getInjectionField, replaceInjectionField, createInjectionField, deleteInjectionFields } from '../controllers/injection_field/injectionFieldController';

package/dist/controllers/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteInjectionFields = exports.createInjectionField = exports.replaceInjectionField = exports.getInjectionField = exports.listInjectionFields = exports.getItemDataTypes = exports.deleteItems = exports.listItems = exports.getItem = exports.updateItem = exports.createItem = exports.getLocationDataTypes = exports.deleteLocations = exports.listLocations = exports.getLocation = exports.updateLocation = exports.createLocation = exports.getRegionDataTypes = exports.deleteRegions = exports.listRegions = exports.getRegion = exports.updateRegion = exports.createRegion = exports.getUserDataTypes = exports.deleteUsers = exports.listUsers = exports.getUser = exports.updateUser = exports.createUser = exports.getAuthToken = void 0;
+var authController_1 = require("../controllers/auth/authController");
+Object.defineProperty(exports, "getAuthToken", { enumerable: true, get: function () { return authController_1.getAuthToken; } });
+var userController_1 = require("../controllers/user/userController");
+Object.defineProperty(exports, "createUser", { enumerable: true, get: function () { return userController_1.createUser; } });
+Object.defineProperty(exports, "updateUser", { enumerable: true, get: function () { return userController_1.updateUser; } });
+Object.defineProperty(exports, "getUser", { enumerable: true, get: function () { return userController_1.getUser; } });
+Object.defineProperty(exports, "listUsers", { enumerable: true, get: function () { return userController_1.listUsers; } });
+Object.defineProperty(exports, "deleteUsers", { enumerable: true, get: function () { return userController_1.deleteUsers; } });
+Object.defineProperty(exports, "getUserDataTypes", { enumerable: true, get: function () { return userController_1.getUserDataTypes; } });
+var regionController_1 = require("../controllers/region/regionController");
+Object.defineProperty(exports, "createRegion", { enumerable: true, get: function () { return regionController_1.createRegion; } });
+Object.defineProperty(exports, "updateRegion", { enumerable: true, get: function () { return regionController_1.updateRegion; } });
+Object.defineProperty(exports, "getRegion", { enumerable: true, get: function () { return regionController_1.getRegion; } });
+Object.defineProperty(exports, "listRegions", { enumerable: true, get: function () { return regionController_1.listRegions; } });
+Object.defineProperty(exports, "deleteRegions", { enumerable: true, get: function () { return regionController_1.deleteRegions; } });
+Object.defineProperty(exports, "getRegionDataTypes", { enumerable: true, get: function () { return regionController_1.getRegionDataTypes; } });
+var locationController_1 = require("../controllers/location/locationController");
+Object.defineProperty(exports, "createLocation", { enumerable: true, get: function () { return locationController_1.createLocation; } });
+Object.defineProperty(exports, "updateLocation", { enumerable: true, get: function () { return locationController_1.updateLocation; } });
+Object.defineProperty(exports, "getLocation", { enumerable: true, get: function () { return locationController_1.getLocation; } });
+Object.defineProperty(exports, "listLocations", { enumerable: true, get: function () { return locationController_1.listLocations; } });
+Object.defineProperty(exports, "deleteLocations", { enumerable: true, get: function () { return locationController_1.deleteLocations; } });
+Object.defineProperty(exports, "getLocationDataTypes", { enumerable: true, get: function () { return locationController_1.getLocationDataTypes; } });
+var itemController_1 = require("../controllers/item/itemController");
+Object.defineProperty(exports, "createItem", { enumerable: true, get: function () { return itemController_1.createItem; } });
+Object.defineProperty(exports, "updateItem", { enumerable: true, get: function () { return itemController_1.updateItem; } });
+Object.defineProperty(exports, "getItem", { enumerable: true, get: function () { return itemController_1.getItem; } });
+Object.defineProperty(exports, "listItems", { enumerable: true, get: function () { return itemController_1.listItems; } });
+Object.defineProperty(exports, "deleteItems", { enumerable: true, get: function () { return itemController_1.deleteItems; } });
+Object.defineProperty(exports, "getItemDataTypes", { enumerable: true, get: function () { return itemController_1.getItemDataTypes; } });
+var injectionFieldController_1 = require("../controllers/injection_field/injectionFieldController");
+Object.defineProperty(exports, "listInjectionFields", { enumerable: true, get: function () { return injectionFieldController_1.listInjectionFields; } });
+Object.defineProperty(exports, "getInjectionField", { enumerable: true, get: function () { return injectionFieldController_1.getInjectionField; } });
+Object.defineProperty(exports, "replaceInjectionField", { enumerable: true, get: function () { return injectionFieldController_1.replaceInjectionField; } });
+Object.defineProperty(exports, "createInjectionField", { enumerable: true, get: function () { return injectionFieldController_1.createInjectionField; } });
+Object.defineProperty(exports, "deleteInjectionFields", { enumerable: true, get: function () { return injectionFieldController_1.deleteInjectionFields; } });

package/dist/controllers/injection_field/injectionFieldController.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response } from "express";
+/** injection_field : create injection field */
+export declare const createInjectionField: (req: Request, res: Response) => Promise<void>;
+/** injection_field : replace injection field */
+export declare const replaceInjectionField: (req: Request, res: Response) => Promise<void>;
+/** injection_field/definition/:id : get injection field (registered) */
+export declare function getInjectionField(req: Request, res: Response): Promise<any>;
+/** injection_fields/injection_field : list injection fields registered */
+export declare const listInjectionFields: (req: Request, res: Response) => Promise<any>;
+/** injection_fields/delete : delete injection fields */
+export declare const deleteInjectionFields: (req: Request, res: Response) => Promise<any>;

package/dist/controllers/injection_field/injectionFieldController.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteInjectionFields = exports.listInjectionFields = exports.replaceInjectionField = exports.createInjectionField = void 0;
+exports.getInjectionField = getInjectionField;
+const utils_1 = require("../../utils");
+const services_1 = require("../../services");
+const payload_1 = require("../../schema/payload");
+const getRootName = (requestInjectionFieldType, toSingular) => {
+    let rootName = ``;
+    switch (requestInjectionFieldType) {
+        case "user":
+            rootName = toSingular ? "injection_field" : "injection_fields";
+            break;
+    }
+    return rootName;
+};
+/** injection_field : create injection field */
+const createInjectionField = async (req, res) => {
+    try {
+        // const requestUserType = req.body.scope.target as InjectionFieldServiceProps["injectionFieldType"]
+        const injectionFieldService = (0, services_1.InjectionFieldService)({
+            ...(0, utils_1.getDefaultServiceProps)(req),
+            injectionFieldType: "user"
+        });
+        let response = {};
+        let reqScope = req.body.scope;
+        let reqPayload = req.body.payload;
+        let request = payload_1.schemaInjectionFieldCreatePayload.parse({
+            scope: {
+                target: reqScope.target,
+                action: reqScope.action
+            },
+            payload: {
+                injection_fields: reqPayload?.injection_fields.map((i) => ({
+                    field_module: `${i.field_module}`,
+                    field_ref: `${i.field_ref}`,
+                    field_key: `${i.field_key}`,
+                    field_type: `${i.field_type}`,
+                }))
+            }
+        });
+        response = await Promise.all(request.payload.injection_fields.map(i => {
+            const payload = {
+                data: {
+                    ...i,
+                    is_multiple: false,
+                    merge_multiple_inline: false,
+                    multiple_count: false,
+                },
+            };
+            return injectionFieldService.createInjectionField(payload);
+        }));
+        (0, utils_1.sendSuccess)(res, response, `Injection Fields created successfully`, `injection_field`);
+    }
+    catch (err) {
+        if (err?.issues) {
+            // Zod validation error
+            (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", `Error: ${err?.message}`, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+            (0, utils_1.sendError)(res, "BAD_REQUEST", "Validation Error", JSON.stringify(err.issues), "", 400);
+            return;
+        }
+        (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", `Error: ${err?.message}`, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    }
+};
+exports.createInjectionField = createInjectionField;
+/** injection_field : replace injection field */
+const replaceInjectionField = async (req, res) => {
+    try {
+        const requestInjectionFieldType = req.body.scope.target;
+        const injectionFieldService = (0, services_1.InjectionFieldService)({
+            ...(0, utils_1.getDefaultServiceProps)(req),
+            injectionFieldType: requestInjectionFieldType
+        });
+        let reqScope = req.body.scope;
+        let reqPayload = req.body.payload;
+        let response = {};
+        if (requestInjectionFieldType === "user") {
+            let request = payload_1.schemaInjectionFieldReplacePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action,
+                },
+                payload: reqPayload
+            });
+            let b = (0, payload_1.groupPayloadInjectionFields)(request.payload.injection_fields, {
+                user: "userId",
+                branch: "branchId",
+            });
+            // console.log('request', JSON.stringify(b))
+            const responseAll = await Promise.all(b.map(async (i) => {
+                const payload = {
+                    injectionFieldType: requestInjectionFieldType,
+                    data: i,
+                };
+                try {
+                    return injectionFieldService.replaceInjectionField(payload);
+                }
+                catch (error) {
+                    // console.log('err', error)
+                    return error;
+                }
+            }));
+            // console.log('responseAll', JSON.stringify(responseAll))
+            response = {
+                [`${getRootName(requestInjectionFieldType, true)}`]: responseAll
+            };
+        }
+        (0, utils_1.sendSuccess)(res, response, `Injection Field(${requestInjectionFieldType}) replaced successfully`);
+    }
+    catch (err) {
+        if (err?.issues) {
+            // Zod validation error
+            (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", `Error: ${err?.message}`, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+            (0, utils_1.sendError)(res, "BAD_REQUEST", "Validation Error", JSON.stringify(err.issues), "", 400);
+            return;
+        }
+        (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", `Error: ${err?.message}`, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    }
+};
+exports.replaceInjectionField = replaceInjectionField;
+/** injection_field/definition/:id : get injection field (registered) */
+async function getInjectionField(req, res) {
+    try {
+        const { id } = req.params;
+        const requestQuery = req.query;
+        const injectionFieldService = (0, services_1.InjectionFieldService)({
+            ...(0, utils_1.getDefaultServiceProps)(req),
+            injectionFieldType: "user" // any
+        });
+        const data = await injectionFieldService.getInjectionField({ id: Number(id), datatypes: requestQuery.datatypes });
+        return (0, utils_1.sendSuccess)(res, data, "Retrieved successfully", `injection_field`);
+    }
+    catch (error) {
+        (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", `Error: ${error?.message}`, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    }
+}
+/** injection_fields/injection_field : list injection fields registered */
+const listInjectionFields = async (req, res) => {
+    try {
+        const requestQuery = req.query;
+        // const requestInjectionFieldType = req.params.locationType as InjectionFieldServiceProps["injectionFieldType"];
+        const injectionFieldService = (0, services_1.InjectionFieldService)({
+            ...(0, utils_1.getDefaultServiceProps)(req),
+            injectionFieldType: "document" // any
+        });
+        let payload = requestQuery;
+        payload = {
+            ...requestQuery
+        };
+        const { data, total } = await injectionFieldService.listInjectionFields(payload);
+        let response = {
+            [`injection_fields`]: data,
+            total,
+        };
+        return (0, utils_1.sendSuccess)(res, response, "Retrieved successfully");
+    }
+    catch (error) {
+        (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", error?.message, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    }
+};
+exports.listInjectionFields = listInjectionFields;
+/** injection_fields/delete : delete injection fields */
+const deleteInjectionFields = async (req, res) => {
+    try {
+        const requestInjectionFieldType = req.body.scope.target;
+        // const requestQuery = req.query as unknown as QueryList;
+        // const requestFileId = Number(req.params.fileId)
+        const request = payload_1.schemaInjectionFieldDeletePayload.parse(req.body);
+        const injectionFieldService = (0, services_1.InjectionFieldService)({
+            ...(0, utils_1.getDefaultServiceProps)(req),
+            injectionFieldType: requestInjectionFieldType
+        });
+        const payload = {
+            injectionFieldIds: request.payload.ids.map(i => BigInt(i))
+        };
+        const data = await injectionFieldService.removeInjectionFields(payload);
+        return (0, utils_1.sendSuccess)(res, data, "Deleted", `injection_fields`);
+    }
+    catch (error) {
+        (0, utils_1.sendError)(res, "INTERNAL_SERVER_ERROR", "Internal Server Error", error?.message, "", utils_1.HTTP_STATUS.INTERNAL_SERVER_ERROR);
+    }
+};
+exports.deleteInjectionFields = deleteInjectionFields;

package/dist/controllers/item/itemController.d.ts

@@ -0,0 +1,13 @@
+import { Request, Response } from "express";
+/** item/:itemType/:itemId : get item */
+export declare function getItem(req: Request, res: Response): Promise<any>;
+/** item : create item */
+export declare const createItem: (req: Request, res: Response) => Promise<void>;
+/** item/:itemId : update item */
+export declare const updateItem: (req: Request, res: Response) => Promise<void>;
+/** items : list items */
+export declare const listItems: (req: Request, res: Response) => Promise<any>;
+/** items/delete : delete items */
+export declare const deleteItems: (req: Request, res: Response) => Promise<any>;
+/** item/data_types/:itemType : get item data types */
+export declare const getItemDataTypes: (req: Request, res: Response) => Promise<any>;