@kava/kava-api-core 1.0.0 → 1.0.2

package/src/permission/index.ts

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

package/src/{permission.util.ts → permission/permission.ts}

@@ -1,136 +1,136 @@
-import { ControllerContext } from "elysia"
-
-type   KeyDigit            =  "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"
-export type KeyFeature     =  `${"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"}${KeyDigit}${KeyDigit}`
-export type KeyAccess      =  `${KeyDigit}${KeyDigit}`
-export type KeyPermission  =  `${KeyFeature}.${KeyAccess}` | KeyAccess
-
-const features = new Map<KeyFeature, { key: KeyFeature; name: string }>()
-const accesses = new Map<KeyAccess, any>()
-
-type FeatureAccess = Partial<Record<KeyFeature, {
-  name: string
-  accesses: Partial<Record<KeyAccess, string>>
-}>>
-
-export const permission = {
-  register: (def: FeatureAccess) => {
-    const featureAccessMap = new Map<string, string>()
-    let defaultFeature: KeyFeature | null = null
-
-    for (const [featureKey, feature] of Object.entries(def)) {
-      if (!defaultFeature) defaultFeature = featureKey as KeyFeature
-
-      registerFeature({
-        key: featureKey as KeyFeature,
-        name: feature.name
-      })
-
-      for (const [accessKey, accessName] of Object.entries(feature.accesses)) {
-        const permKey =
-          `${featureKey}.${String(accessKey).padStart(2, "0")}`
-
-        registerAccess({
-          featureKey,
-          accessKey,
-          accessName,
-          permKey
-        })
-
-        featureAccessMap.set(
-          `${featureKey}.${accessKey}`,
-          permKey
-        )
-      }
-    }
-
-    return createScopeApi(defaultFeature!)
-  },
-  
-  getFeatures: () => [...features.values()],
-
-  getAccesses: () => {
-    const result: Record<string, {
-      key: string
-      name: string
-      accesses: { key: string; name: string }[]
-    }> = {}
-
-    for (const feature of features.values()) {
-      result[String(feature.key)] = {
-        key: String(feature.key),
-        name: feature.name,
-        accesses: []
-      }
-    }
-
-    for (const access of accesses.values()) {
-      const featureKey = String(access.featureKey)
-
-      if (!result[featureKey]) continue
-
-      result[featureKey].accesses.push({
-        key: String(access.accessKey).padStart(2, "0"),
-        name: access.accessName
-      })
-    }
-
-    return Object.values(result)
-  },
-}
-
-
-function normalize(
-  raw: KeyPermission,
-  defaultFeature?: KeyFeature
-): KeyPermission {
-  if (!raw.includes(".") && defaultFeature) {
-    return `${defaultFeature}.${String(raw).padStart(2, "0") as KeyAccess}`
-  }
-
-  return raw
-}
-
-function registerFeature(f: { key: KeyFeature; name: string }) {
-  if (!features.has(f.key)) {
-    features.set(f.key, f)
-  }
-}
-
-function registerAccess(a: any) {
-  if (!accesses.has(a.permKey)) {
-    accesses.set(a.permKey, a)
-  }
-}
-
-function createPermission(keys: KeyPermission[]) {
-  return {
-    keys,
-
-    orHave(raw: KeyPermission) {
-      return createPermission([
-        ...this.keys,
-        normalize(raw) as KeyPermission
-      ])
-    },
-
-    guard(c: ControllerContext) {
-      const permissions = new Set(c.permissions || [])
-
-      const ok = this.keys.some(k => permissions?.has(k))
-      if (!ok) {
-        c.responseForbidden()
-      }
-    }
-  }
-}
-
-export function createScopeApi(defaultFeature: KeyFeature) {
-  return {
-    have(raw: KeyPermission) {
-      const key = normalize(raw, defaultFeature)
-      return createPermission([key])
-    }
-  }
-}
-
+import { ControllerContext } from "elysia"
+
+type   KeyDigit            =  "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"
+export type KeyFeature     =  `${"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"}${KeyDigit}${KeyDigit}`
+export type KeyAccess      =  `${KeyDigit}${KeyDigit}`
+export type KeyPermission  =  `${KeyFeature}.${KeyAccess}` | KeyAccess
+
+const features = new Map<KeyFeature, { key: KeyFeature; name: string }>()
+const accesses = new Map<KeyAccess, any>()
+
+type FeatureAccess = Partial<Record<KeyFeature, {
+  name: string
+  accesses: Partial<Record<KeyAccess, string>>
+}>>
+
+export const permission = {
+  register: (def: FeatureAccess) => {
+    const featureAccessMap = new Map<string, string>()
+    let defaultFeature: KeyFeature | null = null
+
+    for (const [featureKey, feature] of Object.entries(def)) {
+      if (!defaultFeature) defaultFeature = featureKey as KeyFeature
+
+      registerFeature({
+        key: featureKey as KeyFeature,
+        name: feature.name
+      })
+
+      for (const [accessKey, accessName] of Object.entries(feature.accesses)) {
+        const permKey =
+          `${featureKey}.${String(accessKey).padStart(2, "0")}`
+
+        registerAccess({
+          featureKey,
+          accessKey,
+          accessName,
+          permKey
+        })
+
+        featureAccessMap.set(
+          `${featureKey}.${accessKey}`,
+          permKey
+        )
+      }
+    }
+
+    return createScopeApi(defaultFeature!)
+  },
+  
+  getFeatures: () => [...features.values()],
+
+  getAccesses: () => {
+    const result: Record<string, {
+      key: string
+      name: string
+      accesses: { key: string; name: string }[]
+    }> = {}
+
+    for (const feature of features.values()) {
+      result[String(feature.key)] = {
+        key: String(feature.key),
+        name: feature.name,
+        accesses: []
+      }
+    }
+
+    for (const access of accesses.values()) {
+      const featureKey = String(access.featureKey)
+
+      if (!result[featureKey]) continue
+
+      result[featureKey].accesses.push({
+        key: String(access.accessKey).padStart(2, "0"),
+        name: access.accessName
+      })
+    }
+
+    return Object.values(result)
+  },
+}
+
+
+function normalize(
+  raw: KeyPermission,
+  defaultFeature?: KeyFeature
+): KeyPermission {
+  if (!raw.includes(".") && defaultFeature) {
+    return `${defaultFeature}.${String(raw).padStart(2, "0") as KeyAccess}`
+  }
+
+  return raw
+}
+
+function registerFeature(f: { key: KeyFeature; name: string }) {
+  if (!features.has(f.key)) {
+    features.set(f.key, f)
+  }
+}
+
+function registerAccess(a: any) {
+  if (!accesses.has(a.permKey)) {
+    accesses.set(a.permKey, a)
+  }
+}
+
+function createPermission(keys: KeyPermission[]) {
+  return {
+    keys,
+
+    orHave(raw: KeyPermission) {
+      return createPermission([
+        ...this.keys,
+        normalize(raw) as KeyPermission
+      ])
+    },
+
+    guard(c: ControllerContext) {
+      const permissions = new Set(c.permissions || [])
+
+      const ok = this.keys.some(k => permissions?.has(k))
+      if (!ok) {
+        c.responseForbidden()
+      }
+    }
+  }
+}
+
+export function createScopeApi(defaultFeature: KeyFeature) {
+  return {
+    have(raw: KeyPermission) {
+      const key = normalize(raw, defaultFeature)
+      return createPermission([key])
+    }
+  }
+}
+

package/src/registry/index.ts

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

package/src/registry/registry.ts

@@ -0,0 +1,37 @@
+export interface RedisService {
+  get(key: string): Promise<string | null>;
+  setex(key: string, ttl: number, value: string): Promise<any>;
+  del(key: string | string[]): Promise<any>;
+  [key: string]: any;
+}
+
+export interface QueueService {
+  add(name: string, data: any, options?: any): Promise<any>;
+  [key: string]: any;
+}
+
+export interface Registry {
+  redis?: RedisService;
+  queue?: QueueService;
+  [key: string]: any;
+}
+
+class ServiceRegistry {
+  private services: Registry = {};
+
+  /**
+   * Register an optional service instance.
+   */
+  register<K extends keyof Registry>(name: K, service: Registry[K]): void {
+    this.services[name] = service;
+  }
+
+  /**
+   * Retrieve a registered service instance.
+   */
+  get<K extends keyof Registry>(name: K): Registry[K] {
+    return this.services[name];
+  }
+}
+
+export const registry = new ServiceRegistry();

package/src/route/index.ts

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

package/src/{route.util.ts → route/route.ts}

@@ -1,12 +1,12 @@
-// ================================>
-// ## Route: Basic api routers
-// ================================>
-export function api(app: any, basePath: string, controller: any) {
-  return app.group(basePath, (group: any) => group
-    .get("/", controller.index)
-    .post("/", controller.store)
-    .get("/:id", controller.show)
-    .put("/:id", controller.update)
-    .delete("/:id", controller.destroy)
-  )
+// ================================>
+// ## Route: Basic api routers
+// ================================>
+export function api(app: any, basePath: string, controller: any) {
+  return app.group(basePath, (group: any) => group
+    .get("/", controller.index)
+    .post("/", controller.store)
+    .get("/:id", controller.show)
+    .put("/:id", controller.update)
+    .delete("/:id", controller.destroy)
+  )
 }

package/src/storage/index.ts

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

package/src/{storage.util.ts → storage/storage.ts}

@@ -1,102 +1,102 @@
-import fs from "fs";
-import path from "path";
-import { Elysia } from "elysia";
-import { db } from "@utils/db.util";
-
-
-
-// ================================>
-// ## Storage: Middleware storage handler
-// ================================>
-export const storage = (app: Elysia) => app.get("/storage/*", async ({ params, set, user }: Record<string, any>) => {
-  const requestedPath  =  params["*"];
-  const baseDir        =  path.resolve("storage", "public");
-  const targetPath     =  path.resolve(baseDir, requestedPath);
-
-  if (!targetPath.startsWith(baseDir)) {
-    set.status = 400;
-    return { error: "Invalid path" };
-  }
-
-  if (fs.existsSync(targetPath)) {
-    const ext = path.extname(targetPath).toLowerCase();
-    const mimeTypes: Record<string, string> = {
-      ".jpg"   :  "image/jpeg",
-      ".jpeg"  :  "image/jpeg",
-      ".png"   :  "image/png",
-      ".webp"  :  "image/webp",
-      ".gif"   :  "image/gif",
-      ".pdf"   :  "application/pdf",
-      ".txt"   :  "text/plain",
-      ".json"  :  "application/json",
-      ".svg"   :  "image/svg+xml",
-    };
-
-    const buffer = fs.readFileSync(targetPath);
-
-    set.headers["Content-Type"] = mimeTypes[ext] || "application/octet-stream";
-    set.headers["Content-Length"] = buffer.length.toString();
-
-    return new Response(buffer);
-  } else {
-    const baseDir        =  path.resolve("storage", "private");
-    const targetPath     =  path.resolve(baseDir, requestedPath);
-
-    if (fs.existsSync(targetPath)) {
-      if (!user) {
-        set.status = 404
-        return { error: "File not found" };
-      }
-
-      const file = await db("storages").where({ path: requestedPath, disk: "private" }).first()
-
-      if (!file) {
-        set.status = 404
-        return { error: "File not found" }
-      }
-
-      let hasAccess = file.user_id === user.id
-
-      if (!hasAccess) {
-        hasAccess = await db("storage_permissions").where("storage_id", file.id)
-          .andWhere((q) => {
-            q.where("user_id", user.id)
-            .orWhere("role_id", user.role_id)
-          })
-          .first().then(Boolean)
-      }
-
-
-      if (!hasAccess) {
-        set.status = 404
-        return { error: "File not found" }
-      }
-
-    } else {
-      set.status = 404;
-      return { error: "File not found" };
-    }
-
-    const ext = path.extname(targetPath).toLowerCase();
-    const mimeTypes: Record<string, string> = {
-      ".jpg"   :  "image/jpeg",
-      ".jpeg"  :  "image/jpeg",
-      ".png"   :  "image/png",
-      ".webp"  :  "image/webp",
-      ".gif"   :  "image/gif",
-      ".pdf"   :  "application/pdf",
-      ".txt"   :  "text/plain",
-      ".json"  :  "application/json",
-      ".svg"   :  "image/svg+xml",
-    };
-
-    const buffer = fs.readFileSync(targetPath);
-
-    set.headers["Content-Type"] = mimeTypes[ext] || "application/octet-stream";
-    set.headers["Content-Length"] = buffer.length.toString();
-
-    return new Response(buffer);
-  }
-
-  
+import fs from "fs";
+import path from "path";
+import { Elysia } from "elysia";
+import { db } from "@utils";
+
+
+
+// ================================>
+// ## Storage: Middleware storage handler
+// ================================>
+export const storage = (app: Elysia) => app.get("/storage/*", async ({ params, set, user }: Record<string, any>) => {
+  const requestedPath  =  params["*"];
+  const baseDir        =  path.resolve("storage", "public");
+  const targetPath     =  path.resolve(baseDir, requestedPath);
+
+  if (!targetPath.startsWith(baseDir)) {
+    set.status = 400;
+    return { error: "Invalid path" };
+  }
+
+  if (fs.existsSync(targetPath)) {
+    const ext = path.extname(targetPath).toLowerCase();
+    const mimeTypes: Record<string, string> = {
+      ".jpg"   :  "image/jpeg",
+      ".jpeg"  :  "image/jpeg",
+      ".png"   :  "image/png",
+      ".webp"  :  "image/webp",
+      ".gif"   :  "image/gif",
+      ".pdf"   :  "application/pdf",
+      ".txt"   :  "text/plain",
+      ".json"  :  "application/json",
+      ".svg"   :  "image/svg+xml",
+    };
+
+    const buffer = fs.readFileSync(targetPath);
+
+    set.headers["Content-Type"] = mimeTypes[ext] || "application/octet-stream";
+    set.headers["Content-Length"] = buffer.length.toString();
+
+    return new Response(buffer);
+  } else {
+    const baseDir        =  path.resolve("storage", "private");
+    const targetPath     =  path.resolve(baseDir, requestedPath);
+
+    if (fs.existsSync(targetPath)) {
+      if (!user) {
+        set.status = 404
+        return { error: "File not found" };
+      }
+
+      const file = await db("storages").where({ path: requestedPath, disk: "private" }).first()
+
+      if (!file) {
+        set.status = 404
+        return { error: "File not found" }
+      }
+
+      let hasAccess = file.user_id === user.id
+
+      if (!hasAccess) {
+        hasAccess = await db("storage_permissions").where("storage_id", file.id)
+          .andWhere((q) => {
+            q.where("user_id", user.id)
+            .orWhere("role_id", user.role_id)
+          })
+          .first().then(Boolean)
+      }
+
+
+      if (!hasAccess) {
+        set.status = 404
+        return { error: "File not found" }
+      }
+
+    } else {
+      set.status = 404;
+      return { error: "File not found" };
+    }
+
+    const ext = path.extname(targetPath).toLowerCase();
+    const mimeTypes: Record<string, string> = {
+      ".jpg"   :  "image/jpeg",
+      ".jpeg"  :  "image/jpeg",
+      ".png"   :  "image/png",
+      ".webp"  :  "image/webp",
+      ".gif"   :  "image/gif",
+      ".pdf"   :  "application/pdf",
+      ".txt"   :  "text/plain",
+      ".json"  :  "application/json",
+      ".svg"   :  "image/svg+xml",
+    };
+
+    const buffer = fs.readFileSync(targetPath);
+
+    set.headers["Content-Type"] = mimeTypes[ext] || "application/octet-stream";
+    set.headers["Content-Length"] = buffer.length.toString();
+
+    return new Response(buffer);
+  }
+
+  
 });

package/src/validation/index.ts

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