@kava/kava-api-core 1.0.0

package/src/controller.util.ts

@@ -0,0 +1,237 @@
+import fs from "fs";
+import path from "path";
+import "elysia";
+import { Elysia, Context } from "elysia";
+import { validate, logger, KeyPermission, db, ValidationRules, ValidationRule } from "@utils";
+
+
+
+declare module "elysia" {
+  interface ControllerContext extends Context {
+    getQuery                :  {
+      paginate            :  number;
+      page                :  number;
+      sort                :  string[];
+      filter              :  Record<string, string>;
+      search              :  string;
+      searchable          :  string[];
+      selectable          :  string[];
+      selectableOption    :  string[];
+      expand              :  string[];
+    };
+
+    responseData            :  (
+      data                :  any[],
+      totalRow           ?:  number,
+      message            ?:  string,
+      columns            ?:  string[],
+      access             ?:  string[]
+    ) => { 
+      status                : number; 
+      body                  : any 
+    };
+
+    validation              :  <T extends object>(rules: Partial<Record<keyof T | string, ValidationRule[] | string>>) => any;
+    responseError           :  (error: any, section?: string, message?: string, debug?: boolean) => any;
+    responseErrorValidation :  (errors: Record<string, string[]>) => any;
+    responseSaved           :  (data: any, message?: string) => any;
+    responseSuccess         :  (data: any, message?: string) => any;
+    responseForbidden       :  (message?: string) => any;
+    uploadFile              :  (file: File, folder?: string) => Promise<string>;
+    deleteFile              :  (filePath: string) => void;
+    user                   ?:  any
+    permissions            ?:  KeyPermission[],
+    payload                 :  Record<string, any>
+  }
+}
+
+export type ValidationRulesFor<T> = Partial<
+  Record<keyof T | string, ValidationRule[] | string>
+>
+
+
+export const controller = (app: Elysia) => app.derive(({ query, body, status }) => ({
+
+  // =====================================>
+  // ## Basic fetching data query
+  // =====================================>
+  getQuery: {
+    page              :  query.page              ?   Number(query.page)                                  :    1,
+    paginate          :  query.paginate          ?   Number(query.paginate)                              :    10,
+    search            :  query.search            ?   query.search                                        :    "",
+    sort              :  query.sort              ?   JSON.parse(query.sort)                        :   ["created_at desc"],
+    filter            :  query.filter            ?   JSON.parse(query.filter)                      :    [],
+    searchable        :  query.searchable        ?   JSON.parse(query.searchable)                  :    [],
+    selectable        :  query.selectable        ?   JSON.parse(query.selectable)                  :    [],
+    selectableOption  :  query.selectableOption  ?   JSON.parse(query.selectableOption)            :    [],
+    expand            :  query.expand            ?   JSON.parse(query.expand)                      :    [],
+  },
+
+
+
+  // ===================================>
+  // ## Validation request body
+  // ===================================>
+  validation: async <T extends object>(
+    rules: Partial<Record<keyof T | string, ValidationRules[] | string>>
+  ) => {
+    const result = await validate(
+      body as Record<string, any>,
+      rules as ValidationRules
+    )
+
+    if (!result.valid) {
+      throw status(422, {
+        message: "Error: Unprocessable Entity!",
+        errors: result.errors,
+      })
+    }
+  },
+
+
+
+
+  // ====================================>
+  // ## Response error validation
+  // ====================================>
+  responseErrorValidation: (errors: Record<string, string[]>) => {
+    throw status(422, {
+      message: "Error: Unprocessable Entity!",
+      errors: errors,
+    })
+  },
+
+
+
+  // ====================================>
+  // ## Response error
+  // ====================================>
+  responseError: (error: any, section?: string, message?: string, debug = (process.env.APP_DEBUG || true)) => {
+    logger.error(`Error: ${error}`, { error: error, feature: section })
+
+    if (debug) {
+      throw status(500, {
+        message  :  message ?? "Error: Server Side Having Problem!",
+        error    :  error?.message ?? "unknown",
+        section  :  section ?? "unknown",
+      })
+    }
+
+    throw status(500, {
+      message: message ?? "Error: Server Side Having Problem!"
+    })
+  },
+
+
+  // ====================================>
+  // ## Response Forbidden
+  // ====================================>
+  responseForbidden: (message?: string) => {
+    throw status(403, {
+      message: message ?? "Access Forbidden!"
+    })
+  },
+
+
+  // ====================================> 
+  // ## Response record
+  // ====================================>
+  responseData: (data: any[], totalRow?: number, message?: string) => {
+    throw status(200, {
+      message    :  message ?? (data.length ? "Success" : "Empty data"),
+      data       :  data ?? [],
+      total_row  :  totalRow ?? null,
+    });
+  },
+
+
+
+  // ===================================>
+  // ## Response success
+  // ===================================>
+  responseSuccess: (data: any, message?: string, code?: 200 | 201) => {
+    throw status(code || 200, {
+      message  :  message ?? "Success",
+      data     :  data ?? [],
+    })
+  },
+
+
+
+  // ===================================>
+  // ## Response saved record
+  // ===================================>
+  responseSaved: (data: any, message?: string) => {
+    throw status(201, {
+      message  :  message ?? "Success",
+      data     :  data ?? [],
+    })
+  },
+
+
+
+  // ===================================>
+  // ## Upload file
+  // ===================================>
+  uploadFile: async (file: File, folder = "uploads", options?: { disk?: "public" | "private", owner_id?: number, permissions?: { user_id?: number; role_id?: number }[]}): Promise<string> => {
+    const disk = options?.disk ?? "public"
+
+    const dir = path.resolve("storage", disk, folder);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const fileName = `${Date.now().toString(36)}${Math.random().toString(36).substring(2, 18)}${path.extname(file.name).toLowerCase()}`;
+    const filePath = path.join(dir, fileName);
+
+    const buffer = Buffer.from(await file.arrayBuffer());
+
+    fs.writeFileSync(filePath, buffer);
+
+    const relativePath = `/${folder}/${fileName}`
+
+    if(options) {
+      const [storage] = await db("storages").insert({
+        user_id     :  options?.owner_id ?? null,
+        disk        :  disk,
+        path        :  relativePath,
+        filename    :  file.name,
+        filetype    :  file.type,
+        filesize    :  buffer.length,
+        created_at  :  new Date(),
+      }).returning(["id"])
+
+      if (options?.permissions?.length) {
+        const permissions = options.permissions.map(p => ({
+          storage_id  :  storage.id,
+          user_id     :  p.user_id ?? null,
+          role_id     :  p.role_id ?? null,
+          created_at  :  new Date(),
+        }))
+
+        await db("storage_permissions").insert(permissions)
+      }
+    }
+
+
+    return relativePath
+  },
+
+
+
+  // ==================================>
+  // ## Delete File
+  // ==================================>
+  deleteFile: async (filePath: string) => {
+    if (fs.existsSync(filePath)) { 
+      const record = await db("storages").where("path", filePath).first()
+      
+      if(record) {
+        await db("storages").where("id", record.id).delete()
+        await db("storage_permissions").where("storage_id", record.id).delete()
+      }
+
+      fs.unlinkSync(filePath); return true; 
+    }
+  
+    return false;
+  },
+}));

package/src/conversion.util.ts

@@ -0,0 +1,65 @@
+export const conversion = {
+
+  // =============================>
+  // ## Conversion: String formatter 
+  // =============================>
+  strSnake(value: string, delimiter: string = "_"): string {
+    return toWords(value).join(delimiter)
+  },
+
+  strSlug(value: string, delimiter: string = "-"): string {
+    return toWords(value).join(delimiter);
+  },
+
+  strCamel(value: string, delimiter: string = ""): string {
+    return toWords(value).map((w, i) => i === 0 ? w : w[0].toUpperCase() + w.slice(1)).join(delimiter);
+  },
+
+  strPascal(value: string, delimiter: string = ""): string {
+    return toWords(value).map(w => w[0].toUpperCase() + w.slice(1)).join(delimiter);
+  },
+
+  strPlural(value: string): string {
+    const match = value.match(/^(.*?)([A-Za-z]+)$/)
+    if (!match) return value
+
+    const [, prefix, word] = match
+
+    if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) {
+      return prefix + word.slice(0, -1) + "ies"
+    }
+
+    if (!word.endsWith("s")) return prefix + word + "s"
+
+    return value
+  },
+
+  strSingular(value: string): string {
+    const match = value.match(/^(.*?)([A-Za-z]+)$/)
+    if (!match) return value
+
+    const [, prefix, word] = match
+
+    if (word.endsWith("ies")) {
+      return prefix + word.slice(0, -3) + "y"
+    }
+
+    if (word.endsWith("s") && !word.endsWith("ss")) {
+      return prefix + word.slice(0, -1)
+    }
+
+    return value
+  }
+};
+
+
+
+function toWords(value: string): string[] {
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_\-\s]+/g, " ")
+    .trim()
+    .toLowerCase()
+    .split(" ")
+    .filter(Boolean)
+}

package/src/db.util.ts

@@ -0,0 +1,405 @@
+import knex, { Knex } from 'knex'
+
+// ==============================
+// ## Driver resolver
+// ==============================
+function resolveDriver(conn?: string): 'pg' | 'mysql2' {
+  if (!conn) return 'pg'
+
+  const v = conn.toLowerCase()
+  if (['pg', 'pgsql', 'postgres'].includes(v)) return 'pg'
+  if (['mysql', 'mysql2'].includes(v)) return 'mysql2'
+
+  throw new Error(`Unsupported DB_CONNECTION: ${conn}`)
+}
+
+// ==============================
+// ## Knex factory
+// ==============================
+function createKnex(config: {
+  client    ?:  string
+  host      ?:  string
+  port      ?:  number
+  user      ?:  string
+  password  ?:  string
+  database  ?:  string
+}) :  Knex {
+  const client = resolveDriver(config.client)
+
+  return knex({
+    client,
+    connection: {
+      host      :  config.host       ??  '127.0.0.1',
+      port      :  config.port       ??  (client === 'mysql2' ? 3306 : 5432),
+      user      :  config.user       ??  'postgres',
+      password  :  config.password   ??  'password',
+      database  :  config.database   ??  'db_elysia_light',
+    },
+    pool: { min: 2, max: 10 },
+  })
+}
+
+// ==============================
+// ## Connection registry
+// ==============================
+const connections: Record<string, Knex> = {}
+
+// ==============================
+// ## Default connection
+// ==============================
+const DEFAULT_NAME = 'default'
+
+connections[DEFAULT_NAME] = createKnex({
+  client   : process.env.DB_CONNECTION,
+  host     : process.env.DB_HOST,
+  port     : Number(process.env.DB_PORT),
+  user     : process.env.DB_USERNAME,
+  password : process.env.DB_PASSWORD,
+  database : process.env.DB_DATABASE,
+})
+
+// ==============================
+// ## Export default db
+// ==============================
+export const db: Knex = connections[DEFAULT_NAME]
+
+// ==============================
+// ## Named connection (multiple DB)
+// ==============================
+export function useDB(
+  name         :  string,
+  config      ?:  {
+    client    ?:  string
+    host      ?:  string
+    port      ?:  number
+    user      ?:  string
+    password  ?:  string
+    database  ?:  string
+  }
+): Knex {
+  if (!connections[name]) {
+    if (!config) {
+      throw new Error(`DB connection "${name}" not found`)
+    }
+    connections[name] = createKnex(config)
+  }
+
+  return connections[name]
+}
+
+// ==============================
+// ## Close all connections (CLI safe)
+// ==============================
+export async function closeAllDB() {
+  await Promise.all( Object.values(connections).map(db => db.destroy()))
+}
+
+
+
+
+
+declare module "knex" {
+  namespace Knex {
+    interface QueryBuilder<TRecord = any, TResult = any> {
+      where(...args: any[]): this
+      orWhere(...args: any[]): this
+      whereNot(...args: any[]): this
+
+      whereNull(...args: any[]): this
+      whereNotNull(...args: any[]): this
+
+      whereIn(...args: any[]): this
+      whereNotIn(...args: any[]): this
+
+      whereBetween(...args: any[]): this
+      whereNotBetween(...args: any[]): this
+
+      whereExists(...args: any[]): this
+      whereNotExists(...args: any[]): this
+
+      // ===== JOIN =====
+      join(...args: any[]): this
+      leftJoin(...args: any[]): this
+      rightJoin(...args: any[]): this
+      innerJoin(...args: any[]): this
+
+      // ===== SELECT =====
+      select(...args: any[]): this
+      distinct(...args: any[]): this
+
+      // ===== ORDER / LIMIT =====
+      orderBy(...args: any[]): this
+      orderByRaw(...args: any[]): this
+
+      limit(...args: any[]): this
+      offset(...args: any[]): this
+
+      // ===== GROUP =====
+      groupBy(...args: any[]): this
+      having(...args: any[]): this
+
+      // ===== RAW =====
+      whereRaw(...args: any[]): this
+      selectRaw(...args: any[]): this
+
+      joinWith(
+        type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+        table: string,
+        relation:
+          | {
+              localKey: string
+              foreignKey: string
+            }
+          | {
+              pivotTable: string
+              localKey: string
+              pivotLocalKey: string
+              pivotForeignKey: string
+              foreignKey: string
+            },
+        as: string,
+        callback?: (qb: Knex.QueryBuilder) => void
+      ): QueryBuilder<TRecord, TResult>
+
+      whereJoinHas(
+        type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+        table: string,
+        relation:
+          | string
+          | {
+              pivotTable: string
+              localKey: string
+              pivotLocalKey: string
+              pivotForeignKey: string
+              foreignKey: string
+            },
+        foreignKey?: string,
+        callback?: (qb: Knex.QueryBuilder) => void
+      ): QueryBuilder<TRecord, TResult>
+
+      orWhereJoinHas(
+        type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+        table: string,
+        relation:
+          | string
+          | {
+              pivotTable: string
+              localKey: string
+              pivotLocalKey: string
+              pivotForeignKey: string
+              foreignKey: string
+            },
+        foreignKey?: string,
+        callback?: (qb: Knex.QueryBuilder) => void
+      ): QueryBuilder<TRecord, TResult>
+
+      whereJoinDoesntHave(
+        type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+        table: string,
+        relation:
+          | string
+          | {
+              pivotTable: string
+              localKey: string
+              pivotLocalKey: string
+              pivotForeignKey: string
+              foreignKey: string
+            },
+        foreignKey?: string,
+        callback?: (qb: Knex.QueryBuilder) => void
+      ): QueryBuilder<TRecord, TResult>
+
+      orWhereJoinDoesntHave(
+        type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+        table: string,
+        relation:
+          | string
+          | {
+              pivotTable: string
+              localKey: string
+              pivotLocalKey: string
+              pivotForeignKey: string
+              foreignKey: string
+            },
+        foreignKey?: string,
+        callback?: (qb: Knex.QueryBuilder) => void
+      ): QueryBuilder<TRecord, TResult>
+    }
+  }
+}
+
+
+
+function getBaseTable(qb: any): string {
+  return qb._single?.table
+}
+
+function buildWhereHas(
+  qb: Knex.QueryBuilder,
+  type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+  table: string,
+  localKeyOrRelation: any,
+  foreignKey?: string,
+  callback?: (qb: Knex.QueryBuilder) => void
+) {
+  const baseTable = getBaseTable(qb)
+  if (!baseTable) {
+    throw new Error("whereHas harus dipanggil setelah table()")
+  }
+
+  qb.select(1).from(table)
+
+  if (type != "BELONGSTOMANY") {
+    qb.whereRaw(`${foreignKey} = ${baseTable}.${localKeyOrRelation}`)
+  } else {
+    const r = localKeyOrRelation
+    qb.join(r.pivotTable, `${r.pivotTable}.${r.pivotForeignKey}`, `${table}.${r.foreignKey}`).whereRaw(`${r.pivotTable}.${r.pivotLocalKey} = ${baseTable}.${r.localKey}`)
+  }
+
+  if (callback) callback(qb)
+}
+
+
+
+knex.QueryBuilder.extend("joinWith", function (
+  this: Knex.QueryBuilder,
+  type: "BELONGSTO" | "HASONE" | "HASMANY" | "BELONGSTOMANY",
+  table: string,
+  relation:
+    | {
+        localKey: string
+        foreignKey: string
+      }
+    | {
+        pivotTable: string
+        localKey: string
+        pivotLocalKey: string
+        pivotForeignKey: string
+        foreignKey: string
+      },
+  as: string,
+  callback?: (qb: Knex.QueryBuilder) => void
+) {
+  const baseTable = getBaseTable(this)
+  if (!baseTable) throw new Error("joinWith() must be after table()")
+
+  let subquery: string | null = null
+
+  if (type === "BELONGSTO") {
+    const r = relation as any
+
+    subquery = `
+      (
+        select row_to_json(${table})
+        from ${table}
+        where ${table}.${r.foreignKey} = ${baseTable}.${r.localKey}
+        limit 1
+      )
+    `
+  }
+
+  if (type === "HASONE") {
+    const r = relation as any
+
+    subquery = `
+      (
+        select row_to_json(${table})
+        from ${table}
+        where ${table}.${r.foreignKey} = ${baseTable}.${r.localKey}
+        limit 1
+      )
+    `
+  }
+
+  if (type === "HASMANY") {
+    const r = relation as any
+
+    subquery = `
+      (
+        select coalesce(json_agg(${table}), '[]'::json)
+        from ${table}
+        where ${table}.${r.foreignKey} = ${baseTable}.${r.localKey}
+      )
+    `
+  }
+
+  if (type === "BELONGSTOMANY") {
+    const r = relation as any
+
+    subquery = `
+      (
+        select coalesce(json_agg(${table}), '[]'::json)
+        from ${table}
+        inner join ${r.pivotTable}
+          on ${r.pivotTable}.${r.pivotForeignKey} = ${table}.${r.foreignKey}
+        where ${r.pivotTable}.${r.pivotLocalKey} = ${baseTable}.${r.localKey}
+      )
+    `
+  }
+
+  if (!subquery) {
+    throw new Error(`Unsupported relation type: ${type}`)
+  }
+
+  if (callback) {
+    callback(this)
+  }
+
+  return this.select(this.client.raw(`${subquery} as "${as}"`))
+})
+
+
+knex.QueryBuilder.extend("whereJoinHas", function (this: Knex.QueryBuilder, type, table, localKeyOrRelation, foreignKey?, callback? ) {
+  return this.whereExists(function (this: Knex.QueryBuilder) {
+    buildWhereHas(
+      this,
+      type,
+      table,
+      localKeyOrRelation,
+      foreignKey,
+      callback
+    )
+  })
+})
+
+
+knex.QueryBuilder.extend("orJoinWhereHas", function (this: Knex.QueryBuilder, type, table, localKeyOrRelation, foreignKey?, callback? ) {
+  return this.orWhereExists(function (this: Knex.QueryBuilder) {
+    buildWhereHas(
+      this,
+      type,
+      table,
+      localKeyOrRelation,
+      foreignKey,
+      callback
+    )
+  })
+})
+
+
+knex.QueryBuilder.extend("whereJoinDoesntHave", function (this: Knex.QueryBuilder, type, table, localKeyOrRelation, foreignKey?, callback? ) {
+  return this.whereNotExists(function (this: Knex.QueryBuilder) {
+    buildWhereHas(
+      this,
+      type,
+      table,
+      localKeyOrRelation,
+      foreignKey,
+      callback
+    )
+  })
+})
+
+
+knex.QueryBuilder.extend("orWhereJoinDoesntHave", function (this: Knex.QueryBuilder, type, table, localKeyOrRelation, foreignKey?, callback? ) {
+  return this.orWhereNotExists(function (this: Knex.QueryBuilder) {
+    buildWhereHas(
+      this,
+      type,
+      table,
+      localKeyOrRelation,
+      foreignKey,
+      callback
+    )
+  })
+})