seishiro 0.1.6-untest

package/README.md

@@ -0,0 +1,124 @@
+# Seishiro API
+
+Seishiro eliminates the complexity of routing folder structures and replaces them with a single control center. Just use one endpoint, manage it through the Registry, and control your entire application data flow (Web, Mobile, and SSR) with consistent standards.
+
+## Tasks
+
+- [x] Registry Controllers
+- [x] Message Builder Error
+- [x] UnRegistry Base System
+- [x] Multi Language Respon
+- [x] Protocol Response
+- [x] Middleware Runner
+- [x] Action Executed
+- [ ] Versioning Header
+
+## Installation
+
+1. Manual Library Installation
+
+   ```sh
+   npm install seishiro
+   # OR
+   bun add seishiro
+   yarn add seishiro
+   ```
+
+2. Copy the file `./example/api/action.(js/ts)` and then copy some of its structure for the sample. You can manage this system to be much more complex.
+3. Set up and customize it as you like.
+4. Add auth-cookie to put the default placeholder and client version.
+5. Boom! Done!
+
+## Usage
+
+```js
+import dotenv from "dotenv"
+import { UserLogin, UserProfile } from "@/controllers"
+import { MiddlewareSystem } from "@/middlewares"
+import { RegistryBuilder, MessageBuilder, PolicyBuilder, Actions } from "seishiro"
+
+// Init ENV
+dotenv.config()
+
+// Registry
+const registry = new RegistryBuilder()
+registry.set("user:login", UserLogin)
+registry.set("user:profile", UserProfile, MiddlewareSystem) // Using Middleware
+
+// Message Error
+const message = new MessageBuilder("en")
+// Default Variable Message
+message.set("no-response-sending", "Server not response!");
+message.set("no-registry", "Registry not found!");
+message.set("internal-server-error", "Internal server error!");
+// Costum Variable Message
+message.set("user-not-login", "{{username}} has not login!")
+message.set("user-not-found", "{{username}} not found!")
+
+// Rules System
+const policy = new PolicyBuilder({
+  passkey: process.env.SEISHIRO_PASSKEY, // (Require!) For Book Registry Access
+  version_now: "1.4.5", // (Require!) Only support number (0-9.)
+  version_min: "1.4.0", // (Require!) Minimum version
+  version_forceupdate: true, // (Require!) If client on minimum version, client need to force update
+})
+policy.noaction("user:login", ["server-action"]) // block from server action
+policy.noaction("user:login", ["api-action"]) // block from api action
+
+// Action Setup
+const action = new Actions({
+  registry: registry,
+  message: message,
+  policy: policy,
+})
+
+// System Action - For Server Side Rendering
+const sysaction = await action.SystemAction({
+  system: {
+    headers: {...}, // Header KV (Key, Value)
+    cookies: {...}, // Cookie KV (Key, Value)
+    ip: "103.214.146.116", // IP Address (IP Client - Example)
+    location: "JKT, Jakarta, Jakarta Pusat", // Location (Location Client By IP & PeerDB - Example)
+  },
+  type: "user:login", // Type Action
+  data: {
+    email: "testing@localhost.id",
+    password: "testing1234"
+  }
+})
+console.log(sysaction.response) // Response Data
+
+// Server Action - For Server Action (Next.js)
+const serveraction = await action.ServerAction({
+  system: {
+    headers: {...}, // Header KV (Key, Value)
+    cookies: {...}, // Cookie KV (Key, Value)
+    ip: "103.214.146.116", // IP Address (IP Client - Example)
+    location: "JKT, Jakarta, Jakarta Pusat", // Location (Location Client By IP & PeerDB - Example)
+  },
+  type: "user:profile", // Type Action
+  data: {
+    username: "testing1234"
+  }
+})
+console.log(serveraction.response) // Response Data
+
+// API Action - For Rest API
+const apiaction = action.APIAction({
+  system: {
+    headers: {...}, // Header KV (Key, Value)
+    cookies: {...}, // Cookie KV (Key, Value)
+    ip: "103.214.146.116", // IP Address (IP Client - Example)
+    location: "JKT, Jakarta, Jakarta Pusat", // Location (Location Client By IP & PeerDB - Example)
+  },
+  type: "user:profile", // Type Action
+  data: {
+    username: "testing1234"
+  }
+})
+console.log(apiaction.response) // Response Data
+
+// Book Registry (List All Registry On Base Encrypted)
+const bookRegistryJson = action.BookRegistry()
+console.log(bookRegistryJson)
+```

package/helper/format-key.d.ts

@@ -0,0 +1 @@
+export default function formatKey(strkey?: string): string;

package/helper/format-key.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = formatKey;
+function formatKey(strkey = "") {
+    const keyStr = String(strkey || "")
+        .trim()
+        .replace(/[^a-zA-Z0-9-.:]/g, "");
+    return String(keyStr || "");
+}

package/index.d.ts

@@ -0,0 +1,4 @@
+export { default as RegistryBuilder } from "./lib/registry";
+export { default as MessageBuilder } from "./lib/message";
+export { default as PolicyBuilder } from "./lib/policy";
+export { default as Actions } from "./lib/actions";

package/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Actions = exports.PolicyBuilder = exports.MessageBuilder = exports.RegistryBuilder = void 0;
+var registry_1 = require("./lib/registry");
+Object.defineProperty(exports, "RegistryBuilder", { enumerable: true, get: function () { return __importDefault(registry_1).default; } });
+var message_1 = require("./lib/message");
+Object.defineProperty(exports, "MessageBuilder", { enumerable: true, get: function () { return __importDefault(message_1).default; } });
+var policy_1 = require("./lib/policy");
+Object.defineProperty(exports, "PolicyBuilder", { enumerable: true, get: function () { return __importDefault(policy_1).default; } });
+var actions_1 = require("./lib/actions");
+Object.defineProperty(exports, "Actions", { enumerable: true, get: function () { return __importDefault(actions_1).default; } });

package/lib/actions.d.ts

@@ -0,0 +1,135 @@
+import { RegistryParams } from "../types/registry.type";
+import RegistryBuilder from "./registry";
+import MessageBuilder from "./message";
+import PolicyBuilder from "./policy";
+/**
+ * @name Actions
+ */
+export default class Actions {
+    private registry;
+    private message;
+    private policy;
+    constructor({ registry, message, policy, }: {
+        registry: RegistryBuilder;
+        message: MessageBuilder;
+        policy: PolicyBuilder;
+    });
+    BookRegistry(): {
+        iv_length: number;
+        type_base: string;
+        iv: string;
+        data: string;
+    };
+    private ResponseBuilder;
+    SystemAction({ system, middleware, type, data }: RegistryParams): Promise<{
+        header: {
+            key: string;
+            value: unknown;
+        }[];
+        set_cookie: any;
+        rm_cookie: any;
+        status: any;
+        redirect: any;
+        error: any;
+        response: {
+            status: any;
+            message: string;
+            protocol: string;
+            context: string[];
+            params: object[];
+            data?: undefined;
+        };
+    } | {
+        header: {
+            key: string;
+            value: unknown;
+        }[];
+        set_cookie: any;
+        rm_cookie: any;
+        status: any;
+        redirect: any;
+        error: null;
+        response: {
+            status: any;
+            data: any;
+            message?: undefined;
+            protocol?: undefined;
+            context?: undefined;
+            params?: undefined;
+        };
+    }>;
+    ServerAction({ system, middleware, type, data }: RegistryParams): Promise<{
+        header: {
+            key: string;
+            value: unknown;
+        }[];
+        set_cookie: any;
+        rm_cookie: any;
+        status: any;
+        redirect: any;
+        error: any;
+        response: {
+            status: any;
+            message: string;
+            protocol: string;
+            context: string[];
+            params: object[];
+            data?: undefined;
+        };
+    } | {
+        header: {
+            key: string;
+            value: unknown;
+        }[];
+        set_cookie: any;
+        rm_cookie: any;
+        status: any;
+        redirect: any;
+        error: null;
+        response: {
+            status: any;
+            data: any;
+            message?: undefined;
+            protocol?: undefined;
+            context?: undefined;
+            params?: undefined;
+        };
+    }>;
+    APIAction({ system, middleware, type, data }: RegistryParams): Promise<{
+        header: {
+            key: string;
+            value: unknown;
+        }[];
+        set_cookie: any;
+        rm_cookie: any;
+        status: any;
+        redirect: any;
+        error: any;
+        response: {
+            status: any;
+            message: string;
+            protocol: string;
+            context: string[];
+            params: object[];
+            data?: undefined;
+        };
+    } | {
+        header: {
+            key: string;
+            value: unknown;
+        }[];
+        set_cookie: any;
+        rm_cookie: any;
+        status: any;
+        redirect: any;
+        error: null;
+        response: {
+            status: any;
+            data: any;
+            message?: undefined;
+            protocol?: undefined;
+            context?: undefined;
+            params?: undefined;
+        };
+    }>;
+}

package/lib/actions.js

@@ -0,0 +1,175 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * @name Actions
+ */
+class Actions {
+    constructor({ registry, message, policy, }) {
+        this.registry = registry;
+        this.message = message;
+        this.policy = policy;
+    }
+    BookRegistry() {
+        // Default Configuration
+        const algorithm = "aes-256-ctr";
+        const type_base = "hex";
+        const ivLength = 16;
+        const ivKey = crypto_1.default.randomBytes(ivLength);
+        // Dynamic Info
+        const policyInfo = this.policy.apply();
+        const registry = this.registry.apply();
+        const keyencrypt = crypto_1.default
+            .createHash("sha256")
+            .update(String(policyInfo.passkey || "").trim())
+            .digest();
+        // Data List
+        const buildRegistry = {
+            listkey: Object.keys(registry).filter((a) => !policyInfo.noaction_api.includes(a)),
+            version_now: policyInfo.version_now,
+            version_min: policyInfo.version_min,
+            version_forceupdate: policyInfo.version_forceupdate,
+        };
+        // Create Encrypted Data
+        const cipher = crypto_1.default.createCipheriv(algorithm, keyencrypt, ivKey);
+        const results = Buffer.concat([
+            ivKey,
+            cipher.update(JSON.stringify(buildRegistry), "utf-8"),
+            cipher.final(),
+        ]);
+        return {
+            iv_length: ivLength,
+            type_base: type_base,
+            iv: ivKey.toString(type_base),
+            data: results.toString(type_base),
+        };
+    }
+    ResponseBuilder(dataRes = {}, system) {
+        const responseStatus = dataRes.error
+            ? dataRes.status || 400
+            : dataRes.status || 200;
+        const setHeaders = typeof dataRes.headers === "object" && !Array.isArray(dataRes.headers)
+            ? Object.entries(dataRes.headers).map(([key, value]) => {
+                return {
+                    key: key,
+                    value: value,
+                };
+            })
+            : [];
+        const setCookie = Array.isArray(dataRes.set_cookie)
+            ? (dataRes.set_cookie || []).filter((a) => typeof a === "object" && !Array.isArray(a) && a.key && a.value)
+            : [];
+        const rmCookie = Array.isArray(dataRes.rm_cookie)
+            ? (dataRes.rm_cookie || []).filter((a) => typeof a === "object" && !Array.isArray(a) && a.key)
+            : [];
+        const redirect = dataRes.redirect || null;
+        if (dataRes.error || !dataRes || typeof dataRes !== "object") {
+            const buildingMessage = this.message.error(dataRes.error || "system:no-response-sending", []);
+            return {
+                header: setHeaders,
+                set_cookie: setCookie,
+                rm_cookie: rmCookie,
+                status: responseStatus,
+                redirect: redirect,
+                error: dataRes.error || "system:no-response-sending",
+                response: {
+                    status: responseStatus,
+                    message: buildingMessage.message,
+                    protocol: buildingMessage.protocol,
+                    context: buildingMessage.context,
+                    params: buildingMessage.params,
+                },
+            };
+        }
+        return {
+            header: setHeaders,
+            set_cookie: setCookie,
+            rm_cookie: rmCookie,
+            status: responseStatus,
+            redirect: redirect,
+            error: null,
+            response: {
+                status: responseStatus,
+                data: dataRes.data || {},
+            },
+        };
+    }
+    SystemAction(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ system, middleware = {}, type, data }) {
+            try {
+                const showregistry = this.registry;
+                const getregistry = showregistry.get(type || "");
+                if (!getregistry) {
+                    return this.ResponseBuilder({
+                        error: "system:no-registry",
+                        status: 404,
+                    }, system);
+                }
+                if (Array.isArray(getregistry)) {
+                    const middlewareExecuted = yield getregistry[0]({
+                        system,
+                        middleware,
+                        type,
+                        data,
+                    });
+                    const responsesMiddleware = this.ResponseBuilder(middlewareExecuted, system);
+                    const executedResponse = yield getregistry[1]({
+                        system,
+                        middleware: responsesMiddleware,
+                        type,
+                        data,
+                    });
+                    return this.ResponseBuilder(executedResponse, system);
+                }
+                const executedResponse = yield getregistry({
+                    system,
+                    middleware,
+                    type,
+                    data,
+                });
+                return this.ResponseBuilder(executedResponse, system);
+            }
+            catch (error) {
+                return this.ResponseBuilder({
+                    error: "system:internal-server-error",
+                    status: 500,
+                }, system);
+            }
+        });
+    }
+    ServerAction(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ system, middleware, type, data }) {
+            if (this.policy.apply().noaction_server.includes(type || "")) {
+                return this.ResponseBuilder({
+                    error: "system:no-registry",
+                    status: 404,
+                }, system);
+            }
+            return this.SystemAction({ system, middleware, type, data });
+        });
+    }
+    APIAction(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ system, middleware, type, data }) {
+            if (this.policy.apply().noaction_api.includes(type || "")) {
+                return this.ResponseBuilder({
+                    error: "system:no-registry",
+                    status: 404,
+                }, system);
+            }
+            return this.SystemAction({ system, middleware, type, data });
+        });
+    }
+}
+exports.default = Actions;

package/lib/message.d.ts

@@ -0,0 +1,41 @@
+import type { MessageKey, MessageValue, MessageLang, MessageLogic, MessageLogicLang, MessageErrorContext, MessageErrorContextOpt, MessageErrorContextSlug } from "../types/message.type";
+/**
+ * @name MessageBuilder
+ */
+export default class MessageBuilder {
+    private message_build_lang;
+    private message_logic;
+    constructor(language?: MessageLang);
+    /**
+     * @name use
+     * @param string string
+     * @param value string
+     */
+    set(key: MessageKey, value: MessageValue): void;
+    /**
+     * @name get
+     * @param key string
+     */
+    get(key?: MessageKey, lang?: MessageLang): MessageValue;
+    errorMessage(errorSlug?: MessageErrorContextSlug, errorOpt?: MessageErrorContextOpt, lang?: MessageLang): string;
+    /**
+     * @name error
+     * @param errorStr string
+     * @param errorOpts object[]
+     */
+    error(errorStr?: MessageErrorContext, errorOpts?: MessageErrorContextOpt[], lang?: MessageLang): {
+        protocol: string;
+        context: string[];
+        params: object[];
+        message: string;
+    };
+    /**
+     * @name apply
+     */
+    apply(): MessageLogicLang;
+    /**
+     * @name use
+     * @param input MessageBuilder | MessageLogic
+     */
+    use(input: MessageBuilder | MessageLogic): void;
+}

package/lib/message.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_key_1 = __importDefault(require("../helper/format-key"));
+const message_1 = require("../var/message");
+/**
+ * @name MessageBuilder
+ */
+class MessageBuilder {
+    constructor(language = "en") {
+        this.message_build_lang = "";
+        this.message_logic = {};
+        this.message_build_lang = String(language || "en")
+            .toLowerCase()
+            .replace(/[^a-z]/g, "")
+            .slice(0, 2);
+        this.message_logic = {};
+    }
+    /**
+     * @name use
+     * @param string string
+     * @param value string
+     */
+    set(key, value) {
+        const keyStr = (0, format_key_1.default)(key);
+        if (typeof value !== "string") {
+            throw new Error("Message value is only type string!");
+        }
+        if (typeof key !== "string") {
+            throw new Error("Message key is only type string!");
+        }
+        if (!this.message_logic[this.message_build_lang]) {
+            this.message_logic[this.message_build_lang] = {};
+        }
+        this.message_logic[this.message_build_lang][keyStr] = String(value).trim();
+    }
+    /**
+     * @name get
+     * @param key string
+     */
+    get(key = "", lang = this.message_build_lang) {
+        const keyStr = (0, format_key_1.default)(key);
+        let langSupport = lang;
+        // Not Language On Logic
+        if (!this.message_logic[langSupport]) {
+            console.warn("[Debugging Message]: Language not found on logic, using default language!");
+            if (this.message_logic[message_1.DefaultLanguage]) {
+                langSupport = message_1.DefaultLanguage;
+            }
+            else {
+                langSupport = Object.keys(this.message_logic || {})[0];
+            }
+        }
+        if (!this.message_logic[langSupport]) {
+            console.warn("[Debugging Message]: Language or variable not found on logic!");
+            return String(`[!NoneVariable ${keyStr}]`);
+        }
+        // Return
+        return String(this.message_logic[langSupport][keyStr] || "").trim();
+    }
+    errorMessage(errorSlug = "", errorOpt = {}, lang = this.message_build_lang) {
+        let messageContext = this.get(errorSlug, lang);
+        Object.entries(errorOpt || {}).forEach(([keys, values]) => {
+            const pattern = new RegExp(`{{${keys}}}`, "g");
+            messageContext = messageContext.replace(pattern, values);
+        });
+        return messageContext;
+    }
+    /**
+     * @name error
+     * @param errorStr string
+     * @param errorOpts object[]
+     */
+    error(errorStr = "", errorOpts = [], lang = this.message_build_lang) {
+        const [protocol, ...messages] = String(errorStr || "").split(":");
+        const messageContext = String(messages.join(":")).split("|");
+        const messageArrayCtx = messageContext
+            .map((errorSlug, key) => {
+            const getOpt = errorOpts[key];
+            return this.errorMessage(errorSlug, getOpt, lang);
+        })
+            .join(", ");
+        return {
+            protocol: (0, format_key_1.default)(protocol),
+            context: messageContext,
+            params: errorOpts,
+            message: messageArrayCtx,
+        };
+    }
+    /**
+     * @name apply
+     */
+    apply() {
+        return this.message_logic;
+    }
+    /**
+     * @name use
+     * @param input MessageBuilder | MessageLogic
+     */
+    use(input) {
+        if (input instanceof MessageBuilder) {
+            const otherLogic = input.apply();
+            Object.entries(otherLogic).forEach(([lang, messages]) => {
+                if (!this.message_logic[lang]) {
+                    this.message_logic[lang] = {};
+                }
+                Object.assign(this.message_logic[lang], messages);
+            });
+        }
+        else if (typeof input === "object" && input !== null) {
+            Object.entries(input).forEach(([key, value]) => {
+                this.set(key, value);
+            });
+        }
+        else {
+            throw new Error('The "use" input must be a MessageBuilder or mapping object!');
+        }
+    }
+}
+exports.default = MessageBuilder;

package/lib/policy.d.ts

@@ -0,0 +1,33 @@
+import { PolicyNoActionAPIAction, PolicyNoActionServerAction, PolicyNoActionKey, PolicyNoActionBase } from "../types/policy.type";
+/**
+ * @name PolicyBuilder
+ */
+export default class PolicyBuilder {
+    private passkey;
+    private version_now;
+    private version_min;
+    private version_forceupdate;
+    private noaction_api;
+    private noaction_server;
+    constructor({ passkey, version_now, version_min, version_forceupdate, }: {
+        passkey: string;
+        version_now: string;
+        version_min: string;
+        version_forceupdate?: boolean;
+    });
+    noaction(type?: PolicyNoActionKey, action?: PolicyNoActionBase): void;
+    private compareVersions;
+    version_info(version?: string): {
+        info_upgrade: boolean;
+        is_version_min: boolean;
+        is_version_now: boolean;
+    };
+    apply(): {
+        passkey: string;
+        version_now: string;
+        version_min: string;
+        version_forceupdate: boolean;
+        noaction_api: PolicyNoActionAPIAction;
+        noaction_server: PolicyNoActionServerAction;
+    };
+}