@voilabs/oilang 0.0.7 → 0.0.8

package/README.md

@@ -165,6 +165,54 @@ new RedisStore(connectionString: string, options?: { prefix?: string })
 - `connectionString`: Redis connection URL (default: `redis://localhost:6379`).
 - `options.prefix`: specific prefix for Redis keys (default: `oilang:`).
 
+## Frameworks Support
+
+OILang provides built-in handlers to easily integrate with popular web frameworks.
+
+### Elysia.js
+
+The `elysiaHandler` allows you to expose RESTful API endpoints for managing locales and translations directly from your Elysia application.
+
+#### Usage
+
+```typescript
+import { Elysia } from "elysia";
+import { elysiaHandler } from "@voilabs/oilang/handlers";
+
+const app = new Elysia()
+    .use(elysiaHandler(oilang)) // oilang instance
+    .listen(3000);
+```
+
+#### API Endpoints
+
+The handler exposes the following endpoints under the `/oilang` prefix:
+
+[oAH] = onAuthHandle is a function that will be called before handling requests, useful for authentication.
+
+- **GET /oilang/locales**: List all locales.
+- **POST /oilang/locales**: Create a new locale [oAH].
+- **PUT /oilang/locales/:localeCode**: Update a locale [oAH].
+- **DELETE /oilang/locales/:locale**: Delete a locale [oAH].
+- **GET /oilang/translations/:locale**: Get translations for a locale.
+- **POST /oilang/translations/:locale**: Add translations (bulk) [oAH].
+- **PUT /oilang/translations/:locale**: Update translations (bulk) [oAH].
+- **DELETE /oilang/translations/:locale**: Delete translations (bulk) [oAH].
+
+#### Options
+
+You can pass an optional configuration object to `elysiaHandler`:
+
+```typescript
+elysiaHandler(oilang, {
+    onAuthHandle: async ({ request }) => {
+        // Implement authentication logic here
+    },
+});
+```
+
+- `onAuthHandle`: A hook to run before handling requests, useful for authentication.
+
 ## Database Schema
 
 The PostgreSQL adapter automatically creates the necessary tables if they do not exist.

package/dist/adapters/index.d.ts

@@ -0,0 +1 @@
+export * from "./PostgreSQL";

package/dist/adapters/index.js

@@ -0,0 +1 @@
+export * from "./PostgreSQL";

package/dist/handlers/Elysia.d.ts

@@ -0,0 +1,34 @@
+import { OILang } from "../index";
+import Elysia from "elysia";
+type Options = {
+    onAuthHandle?: Elysia["onBeforeHandle"];
+};
+export declare const elysiaHandler: (oilang: OILang, options?: Options) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/handlers/Elysia.js

@@ -0,0 +1,106 @@
+import Elysia, { t } from "elysia";
+const response = (success, message, data) => {
+    return {
+        success,
+        message,
+        data,
+        __oilang: true,
+    };
+};
+export const elysiaHandler = (oilang, options) => {
+    return new Elysia({ name: "oilang" }).group("/oilang", (app) => {
+        app.group("/locales", (localesApp) => {
+            localesApp.get("/", async (app) => {
+                const locales = await oilang.locales.list();
+                return response(true, "Locales fetched successfully", locales);
+            });
+            localesApp.post("/locales", async ({ body }) => {
+                const translations = await oilang.locales.create(body.locale, body.native_name, body.english_name);
+                return response(true, "Locale created successfully", translations);
+            }, {
+                beforeHandle: options?.onAuthHandle,
+                body: t.Object({
+                    locale: t.String(),
+                    native_name: t.String(),
+                    english_name: t.String(),
+                }),
+            });
+            localesApp.put("/locales/:localeCode", async ({ body, params }) => {
+                const { localeCode } = params;
+                const translations = await oilang.locales.update(localeCode, body.native_name, body.english_name);
+                return response(true, "Locale updated successfully", translations);
+            }, {
+                beforeHandle: options?.onAuthHandle,
+                body: t.Object({
+                    native_name: t.String(),
+                    english_name: t.String(),
+                }),
+            });
+            localesApp.delete("/locales/:locale", async ({ params }) => {
+                const translations = await oilang.locales.delete(params.locale);
+                return response(true, "Locale deleted successfully", translations);
+            }, {
+                beforeHandle: options?.onAuthHandle,
+                params: t.Object({
+                    locale: t.String(),
+                }),
+            });
+            return localesApp;
+        });
+        app.group("/translations", (translationsApp) => {
+            translationsApp.get("/:locale", async ({ params, query }) => {
+                const translations = await oilang.translations.list(params.locale);
+                return response(true, "Translations fetched successfully", translations);
+            });
+            translationsApp.post("/:locale", async ({ params, body }) => {
+                const { translations } = body;
+                for (const t of translations) {
+                    await oilang.translations.create(params.locale, {
+                        key: t.key,
+                        value: t.value,
+                    });
+                }
+                return response(true, "Translations updated successfully", {});
+            }, {
+                beforeHandle: options?.onAuthHandle,
+                body: t.Object({
+                    translations: t.Array(t.Object({
+                        key: t.String(),
+                        value: t.String(),
+                    })),
+                }),
+            });
+            translationsApp.put("/:locale", async ({ params, request, body }) => {
+                const { translations } = body;
+                for (const t of translations) {
+                    await oilang.translations.update(params.locale, t.key, t.value);
+                }
+                return response(true, "Translations updated successfully", {});
+            }, {
+                beforeHandle: options?.onAuthHandle,
+                body: t.Object({
+                    translations: t.Array(t.Object({
+                        key: t.String(),
+                        value: t.String(),
+                    })),
+                }),
+            });
+            translationsApp.delete("/:locale", async ({ params, request, body }) => {
+                const { translations } = body;
+                for (const t of translations) {
+                    await oilang.translations.delete(params.locale, t.key);
+                }
+                return response(true, "Translations deleted successfully", {});
+            }, {
+                beforeHandle: options?.onAuthHandle,
+                body: t.Object({
+                    translations: t.Array(t.Object({
+                        key: t.String(),
+                    })),
+                }),
+            });
+            return translationsApp;
+        });
+        return app;
+    });
+};

package/dist/handlers/index.d.ts

@@ -0,0 +1 @@
+export * from "./Elysia";

package/dist/handlers/index.js

@@ -0,0 +1 @@
+export * from "./Elysia";

package/dist/index.d.ts

@@ -1,5 +1,72 @@
-export { OILang } from "./oilang";
-export { PostgreSQL } from "./adapters/PostgreSQL";
-export { MemoryStore } from "./stores/MemoryStore";
-export { RedisStore } from "./stores/RedisStore";
-export * from "./types";
+import type { MemoryStore } from "./stores/MemoryStore";
+import type { PostgreSQL } from "./adapters/PostgreSQL";
+import type { RedisStore } from "./stores/RedisStore";
+import { LocaleData, TranslationData } from "./types";
+type AdapterConfig = {
+    database: InstanceType<typeof PostgreSQL>;
+    store: InstanceType<typeof MemoryStore> | InstanceType<typeof RedisStore>;
+    fallbackLocale?: string;
+};
+type ActionResponse<T> = {
+    error: Error & {
+        code?: string;
+    };
+    data: null;
+} | {
+    error: null;
+    data: T;
+};
+declare class Locale {
+    private database;
+    private store;
+    constructor(database: AdapterConfig["database"], store: AdapterConfig["store"]);
+    list(): Promise<{
+        error: null;
+        data: any[] | Record<string, string>;
+    }>;
+    create(locale: string, nativeName: string, englishName: string): Promise<ActionResponse<LocaleData>>;
+    delete(locale: string): Promise<{
+        error: null;
+        data: {
+            code: string;
+        };
+    } | {
+        error: any;
+        data: null;
+    }>;
+    update(locale: string, nativeName: string, englishName: string): Promise<ActionResponse<LocaleData>>;
+}
+declare class Translation {
+    private database;
+    private store;
+    private fallbackLocale?;
+    constructor(database: AdapterConfig["database"], store: AdapterConfig["store"], fallbackLocale?: string);
+    list(locale: string): Promise<any[] | Record<string, string>>;
+    create(locale: string, config: {
+        key: string;
+        value: string;
+    }): Promise<ActionResponse<TranslationData>>;
+    update(locale: string, key: string, newValue: string): Promise<ActionResponse<TranslationData>>;
+    delete(locale: string, key: string): Promise<{
+        error: null;
+        data: {
+            locale_id: string;
+            key: string;
+        };
+    } | {
+        error: any;
+        data: null;
+    }>;
+    translate(locale: string, key: string, variables?: Record<string, string | number>): Promise<string>;
+}
+export declare class OILang {
+    private config;
+    private database;
+    private store;
+    private fallbackLocale;
+    locales: Locale;
+    translations: Translation;
+    constructor(config: AdapterConfig);
+    init(): Promise<void>;
+}
+export {};

package/dist/index.js

@@ -1,5 +1,224 @@
-export { OILang } from "./oilang";
-export { PostgreSQL } from "./adapters/PostgreSQL";
-export { MemoryStore } from "./stores/MemoryStore";
-export { RedisStore } from "./stores/RedisStore";
-export * from "./types";
+class Locale {
+    database;
+    store;
+    constructor(database, store) {
+        this.database = database;
+        this.store = store;
+    }
+    async list() {
+        const response = await this.store.getAll({
+            seed: "locales",
+        });
+        return {
+            error: null,
+            data: response,
+        };
+    }
+    async create(locale, nativeName, englishName) {
+        const response = await this.database.locales.create(locale, nativeName, englishName);
+        if (response.success) {
+            this.store.set({
+                seed: "locales",
+                locale: response.data,
+            });
+            return {
+                error: null,
+                data: response.data,
+            };
+        }
+        else {
+            return {
+                error: response.error,
+                data: null,
+            };
+        }
+    }
+    async delete(locale) {
+        const response = await this.database.locales.delete(locale);
+        if (response.success) {
+            this.store.remove({
+                seed: "locales",
+                locale,
+            });
+            return {
+                error: null,
+                data: response.data,
+            };
+        }
+        else {
+            return {
+                error: response.error,
+                data: null,
+            };
+        }
+    }
+    async update(locale, nativeName, englishName) {
+        const response = await this.database.locales.update(locale, nativeName, englishName);
+        if (response.success) {
+            this.store.update({
+                seed: "locales",
+                code: locale,
+                locale: {
+                    native_name: nativeName,
+                    english_name: englishName,
+                },
+            });
+            return {
+                error: null,
+                data: response.data,
+            };
+        }
+        else {
+            return {
+                error: response.error,
+                data: null,
+            };
+        }
+    }
+}
+class Translation {
+    database;
+    store;
+    fallbackLocale;
+    constructor(database, store, fallbackLocale) {
+        this.database = database;
+        this.store = store;
+        this.fallbackLocale = fallbackLocale;
+    }
+    async list(locale) {
+        const response = await this.store.getAll({
+            seed: "translations",
+            locale,
+        });
+        return response;
+    }
+    async create(locale, config) {
+        const response = await this.database.translations.create(config.key, config.value, locale);
+        if (response.success) {
+            this.store.set({
+                seed: "translations",
+                locale,
+                key: config.key,
+                value: config.value,
+            });
+            return {
+                error: null,
+                data: response.data,
+            };
+        }
+        else {
+            return {
+                error: response.error,
+                data: null,
+            };
+        }
+    }
+    async update(locale, key, newValue) {
+        const response = await this.database.translations.update(key, newValue, locale);
+        if (response.success) {
+            this.store.update({
+                seed: "translations",
+                locale,
+                key,
+                value: newValue,
+            });
+            return {
+                error: null,
+                data: response.data,
+            };
+        }
+        else {
+            return {
+                error: response.error,
+                data: null,
+            };
+        }
+    }
+    async delete(locale, key) {
+        const response = await this.database.translations.delete(key, locale);
+        if (response.success) {
+            this.store.remove({
+                seed: "translations",
+                locale,
+                key,
+            });
+            return {
+                error: null,
+                data: response.data,
+            };
+        }
+        else {
+            return {
+                error: response.error,
+                data: null,
+            };
+        }
+    }
+    async translate(locale, key, variables) {
+        let translation = await this.store.get({
+            seed: "translations",
+            locale,
+            key,
+        });
+        if (!translation && this.fallbackLocale) {
+            translation = await this.store.get({
+                seed: "translations",
+                locale: this.fallbackLocale,
+                key,
+            });
+        }
+        if (!translation)
+            return key;
+        if (variables) {
+            for (const [varKey, varValue] of Object.entries(variables)) {
+                translation = translation.replace(new RegExp(`{{${varKey}}}`, "g"), String(varValue));
+            }
+        }
+        return translation;
+    }
+}
+export class OILang {
+    config;
+    database;
+    store;
+    fallbackLocale;
+    locales;
+    translations;
+    constructor(config) {
+        this.config = config;
+        this.database = config.database;
+        this.store = config.store;
+        this.fallbackLocale = config.fallbackLocale ?? "en-US";
+        this.locales = new Locale(this.database, this.store);
+        this.translations = new Translation(this.database, this.store, this.fallbackLocale);
+    }
+    async init() {
+        await this.database.connect();
+        const [locales, translations] = await Promise.all([
+            this.database.locales.list(),
+            this.database.translations.list(),
+        ]);
+        if (locales.success && translations.success) {
+            const loadableLocales = locales.data.map((l) => ({
+                code: l.code,
+                native_name: l.native_name,
+                english_name: l.english_name,
+                created_at: l.created_at,
+                updated_at: l.updated_at,
+            }));
+            const loadableTranslations = loadableLocales.reduce((acc, l) => {
+                acc[l.code] = translations.data
+                    .filter((t) => t.locale_id === l.code)
+                    .reduce((accData, t) => {
+                    accData[t.key] = t.value;
+                    return accData;
+                }, {});
+                return acc;
+            }, {});
+            await this.store.load(loadableLocales, loadableTranslations);
+        }
+        else {
+            throw new Error("Failed to load locales or translations");
+        }
+    }
+}

package/dist/stores/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MemoryStore";
+export * from "./RedisStore";

package/dist/stores/index.js

@@ -0,0 +1,2 @@
+export * from "./MemoryStore";
+export * from "./RedisStore";

package/package.json

@@ -1,13 +1,20 @@
 {
     "name": "@voilabs/oilang",
     "description": "A robust internationalization (i18n) handling library designed for performance and flexibility.",
-    "version": "0.0.7",
+    "version": "0.0.8",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {
         "build": "tsc",
         "prepublishOnly": "npm run build"
     },
+    "exports": {
+        "./*": "./dist/*",
+        "./adapters": "./dist/adapters/index.js",
+        "./stores": "./dist/stores/index.js",
+        "./handlers": "./dist/handlers/index.js",
+        "./types": "./dist/types.d.ts"
+    },
     "devDependencies": {
         "@types/bun": "latest",
         "@types/node": "^25.2.3",
@@ -30,6 +37,7 @@
         "url": "git+https://github.com/voilabs/node-oilang.git"
     },
     "dependencies": {
+        "elysia": "^1.4.25",
         "ioredis": "^5.9.3",
         "pg": "^8.18.0"
     },

package/dist/oilang.d.ts

@@ -1,72 +0,0 @@
-import type { MemoryStore } from "./stores/MemoryStore";
-import type { PostgreSQL } from "./adapters/PostgreSQL";
-import type { RedisStore } from "./stores/RedisStore";
-import { LocaleData, TranslationData } from "./types";
-type AdapterConfig = {
-    database: InstanceType<typeof PostgreSQL>;
-    store: InstanceType<typeof MemoryStore> | InstanceType<typeof RedisStore>;
-    fallbackLocale?: string;
-};
-type ActionResponse<T> = {
-    error: Error & {
-        code?: string;
-    };
-    data: null;
-} | {
-    error: null;
-    data: T;
-};
-declare class Locale {
-    private database;
-    private store;
-    constructor(database: AdapterConfig["database"], store: AdapterConfig["store"]);
-    list(): Promise<{
-        error: null;
-        data: any[] | Record<string, string>;
-    }>;
-    create(locale: string, nativeName: string, englishName: string): Promise<ActionResponse<LocaleData>>;
-    delete(locale: string): Promise<{
-        error: null;
-        data: {
-            code: string;
-        };
-    } | {
-        error: any;
-        data: null;
-    }>;
-    update(locale: string, nativeName: string, englishName: string): Promise<ActionResponse<LocaleData>>;
-}
-declare class Translation {
-    private database;
-    private store;
-    private fallbackLocale?;
-    constructor(database: AdapterConfig["database"], store: AdapterConfig["store"], fallbackLocale?: string);
-    list(locale: string): Promise<any[] | Record<string, string>>;
-    create(locale: string, config: {
-        key: string;
-        value: string;
-    }): Promise<ActionResponse<TranslationData>>;
-    update(locale: string, key: string, newValue: string): Promise<ActionResponse<TranslationData>>;
-    delete(locale: string, key: string): Promise<{
-        error: null;
-        data: {
-            locale_id: string;
-            key: string;
-        };
-    } | {
-        error: any;
-        data: null;
-    }>;
-    translate(locale: string, key: string, variables?: Record<string, string | number>): Promise<string>;
-}
-export declare class OILang {
-    private config;
-    private database;
-    private store;
-    private fallbackLocale;
-    locales: Locale;
-    translations: Translation;
-    constructor(config: AdapterConfig);
-    init(): Promise<void>;
-}
-export {};

package/dist/oilang.js

@@ -1,224 +0,0 @@
-class Locale {
-    database;
-    store;
-    constructor(database, store) {
-        this.database = database;
-        this.store = store;
-    }
-    async list() {
-        const response = await this.store.getAll({
-            seed: "locales",
-        });
-        return {
-            error: null,
-            data: response,
-        };
-    }
-    async create(locale, nativeName, englishName) {
-        const response = await this.database.locales.create(locale, nativeName, englishName);
-        if (response.success) {
-            this.store.set({
-                seed: "locales",
-                locale: response.data,
-            });
-            return {
-                error: null,
-                data: response.data,
-            };
-        }
-        else {
-            return {
-                error: response.error,
-                data: null,
-            };
-        }
-    }
-    async delete(locale) {
-        const response = await this.database.locales.delete(locale);
-        if (response.success) {
-            this.store.remove({
-                seed: "locales",
-                locale,
-            });
-            return {
-                error: null,
-                data: response.data,
-            };
-        }
-        else {
-            return {
-                error: response.error,
-                data: null,
-            };
-        }
-    }
-    async update(locale, nativeName, englishName) {
-        const response = await this.database.locales.update(locale, nativeName, englishName);
-        if (response.success) {
-            this.store.update({
-                seed: "locales",
-                code: locale,
-                locale: {
-                    native_name: nativeName,
-                    english_name: englishName,
-                },
-            });
-            return {
-                error: null,
-                data: response.data,
-            };
-        }
-        else {
-            return {
-                error: response.error,
-                data: null,
-            };
-        }
-    }
-}
-class Translation {
-    database;
-    store;
-    fallbackLocale;
-    constructor(database, store, fallbackLocale) {
-        this.database = database;
-        this.store = store;
-        this.fallbackLocale = fallbackLocale;
-    }
-    async list(locale) {
-        const response = await this.store.getAll({
-            seed: "translations",
-            locale,
-        });
-        return response;
-    }
-    async create(locale, config) {
-        const response = await this.database.translations.create(config.key, config.value, locale);
-        if (response.success) {
-            this.store.set({
-                seed: "translations",
-                locale,
-                key: config.key,
-                value: config.value,
-            });
-            return {
-                error: null,
-                data: response.data,
-            };
-        }
-        else {
-            return {
-                error: response.error,
-                data: null,
-            };
-        }
-    }
-    async update(locale, key, newValue) {
-        const response = await this.database.translations.update(key, newValue, locale);
-        if (response.success) {
-            this.store.update({
-                seed: "translations",
-                locale,
-                key,
-                value: newValue,
-            });
-            return {
-                error: null,
-                data: response.data,
-            };
-        }
-        else {
-            return {
-                error: response.error,
-                data: null,
-            };
-        }
-    }
-    async delete(locale, key) {
-        const response = await this.database.translations.delete(key, locale);
-        if (response.success) {
-            this.store.remove({
-                seed: "translations",
-                locale,
-                key,
-            });
-            return {
-                error: null,
-                data: response.data,
-            };
-        }
-        else {
-            return {
-                error: response.error,
-                data: null,
-            };
-        }
-    }
-    async translate(locale, key, variables) {
-        let translation = await this.store.get({
-            seed: "translations",
-            locale,
-            key,
-        });
-        if (!translation && this.fallbackLocale) {
-            translation = await this.store.get({
-                seed: "translations",
-                locale: this.fallbackLocale,
-                key,
-            });
-        }
-        if (!translation)
-            return key;
-        if (variables) {
-            for (const [varKey, varValue] of Object.entries(variables)) {
-                translation = translation.replace(new RegExp(`{{${varKey}}}`, "g"), String(varValue));
-            }
-        }
-        return translation;
-    }
-}
-export class OILang {
-    config;
-    database;
-    store;
-    fallbackLocale;
-    locales;
-    translations;
-    constructor(config) {
-        this.config = config;
-        this.database = config.database;
-        this.store = config.store;
-        this.fallbackLocale = config.fallbackLocale ?? "en-US";
-        this.locales = new Locale(this.database, this.store);
-        this.translations = new Translation(this.database, this.store, this.fallbackLocale);
-    }
-    async init() {
-        await this.database.connect();
-        const [locales, translations] = await Promise.all([
-            this.database.locales.list(),
-            this.database.translations.list(),
-        ]);
-        if (locales.success && translations.success) {
-            const loadableLocales = locales.data.map((l) => ({
-                code: l.code,
-                native_name: l.native_name,
-                english_name: l.english_name,
-                created_at: l.created_at,
-                updated_at: l.updated_at,
-            }));
-            const loadableTranslations = loadableLocales.reduce((acc, l) => {
-                acc[l.code] = translations.data
-                    .filter((t) => t.locale_id === l.code)
-                    .reduce((accData, t) => {
-                    accData[t.key] = t.value;
-                    return accData;
-                }, {});
-                return acc;
-            }, {});
-            await this.store.load(loadableLocales, loadableTranslations);
-        }
-        else {
-            throw new Error("Failed to load locales or translations");
-        }
-    }
-}