@njinlabs/njin 0.1.0

package/src/core/model/index.ts

@@ -0,0 +1,244 @@
+import surreal from "../../modules/surreal";
+import moment from "moment";
+import { RecordId, Table, type Values } from "surrealdb";
+import { z } from "zod";
+
+export type FormMeta = {
+  label: string;
+  unique?: boolean;
+};
+
+export class UniqueConstraintError extends Error {
+  constructor(
+    public readonly field: string,
+    public readonly value: unknown,
+  ) {
+    super(`Field "${field}" must be unique — value already exists`);
+  }
+}
+
+export type ReadMeta = {
+  total: number;
+  page: number;
+  limit: number;
+  pageCount: number;
+};
+
+export type FilterValue = string | Partial<Record<FilterOperator, string>>;
+
+export type FilterOperator =
+  | "$eq"
+  | "$ne"
+  | "$gt"
+  | "$gte"
+  | "$lt"
+  | "$lte"
+  | "$contains"
+  | "$startsWith"
+  | "$in";
+
+export type ReadOptions = {
+  search?: string;
+  page?: number;
+  limit?: number;
+  sort?: string;
+  order?: "asc" | "desc";
+  populate?: string[] | "none";
+  filters?: Record<string, FilterValue>;
+};
+
+
+// Whitelist of operators — unknown operators are silently dropped, never interpolated.
+const OPERATORS: Record<FilterOperator, (field: string, param: string) => string> = {
+  $eq:         (f, p) => `${f} = $${p}`,
+  $ne:         (f, p) => `${f} != $${p}`,
+  $gt:         (f, p) => `${f} > $${p}`,
+  $gte:        (f, p) => `${f} >= $${p}`,
+  $lt:         (f, p) => `${f} < $${p}`,
+  $lte:        (f, p) => `${f} <= $${p}`,
+  $contains:   (f, p) => `string::contains(string::lowercase(${f}), $${p})`,
+  $startsWith: (f, p) => `string::starts_with(string::lowercase(${f}), $${p})`,
+  $in:         (f, p) => `${f} CONTAINS $${p}`,
+};
+
+export const makeModel = <Rules extends z.ZodObject>(
+  prefix: string,
+  config: {
+    schema: Rules;
+    name: string;
+    searchFields: string[];
+  },
+) => {
+  type Data = z.infer<Rules>;
+  type Returning = Data & {
+    id: RecordId;
+    createdAt: string;
+    updatedAt: string;
+  };
+
+  const table = new Table(prefix);
+
+  const relationFields = Object.entries(config.schema.shape)
+    .filter(([, v]) => {
+      const m = (v as z.ZodType).meta() as any;
+      return ["relation", "multi_relation", "file", "multi_file"].includes(m?.renderAs);
+    })
+    .map(([k]) => k);
+
+  const relationFieldSet = new Set(relationFields);
+
+  const uniqueFields = Object.entries(config.schema.shape)
+    .filter(([, v]) => (v as z.ZodType).meta()?.unique === true)
+    .map(([k]) => k);
+
+  const uniqueFieldSet = new Set(uniqueFields);
+
+  // field must be a known unique field — prevents arbitrary field injection
+  const isDuplicate = async (field: string, value: unknown, excludeId?: string) => {
+    if (!uniqueFieldSet.has(field)) return false;
+
+    const excludeClause = excludeId ? "AND id != $excludeId" : "";
+    const [[row]] = await surreal().query<[{ count: number }[]]>(
+      `SELECT count() AS count FROM ${prefix} WHERE ${field} = $value ${excludeClause} GROUP ALL`,
+      { value, excludeId: excludeId ? new RecordId(table, excludeId) : undefined },
+    );
+
+    return (row?.count ?? 0) > 0;
+  };
+
+  const assertUnique = async (data: Record<string, unknown>, excludeId?: string) => {
+    for (const field of uniqueFields) {
+      const value = data[field];
+      if (value === undefined) continue; // partial update without this field — nothing to check
+
+      if (await isDuplicate(field, value, excludeId)) {
+        throw new UniqueConstraintError(field, value);
+      }
+    }
+  };
+
+  const create = async (data: Values<Data>) => {
+    await assertUnique(data);
+
+    return surreal()
+      .create<Data>(table)
+      .content({ ...data, createdAt: moment().toISOString(), updatedAt: moment().toISOString() })
+      .output("after")
+      .then(([data]) => data) as Promise<Returning>;
+  };
+
+  const read = async ({
+    search,
+    page = 1,
+    limit: pageLimit = 20,
+    sort,
+    order = "asc",
+    populate,
+    filters,
+  }: ReadOptions = {}) => {
+    const whereParts: string[] = [];
+    const params: Record<string, unknown> = {};
+
+    if (search && config.searchFields.length) {
+      params.search = search.toLowerCase();
+      whereParts.push(
+        `(${config.searchFields.map((f) => `string::similarity::jaro_winkler(string::lowercase(${f}), $search) > 0.4`).join(" OR ")})`,
+      );
+    }
+
+    if (filters) {
+      for (const [key, value] of Object.entries(filters)) {
+        // key must exist in schema — prevents arbitrary field injection
+        if (!(key in config.schema.shape)) continue;
+
+        if (typeof value === "string") {
+          // Shorthand: filters[field]=value → equality
+          params[`f_${key}`] = value;
+          whereParts.push(`${key} = $f_${key}`);
+        } else {
+          // Operator form: filters[field][$op]=value
+          for (const [op, opValue] of Object.entries(value) as [FilterOperator, string][]) {
+            const builder = OPERATORS[op]; // strict whitelist — unknown ops get undefined
+            if (!builder || opValue === undefined) continue;
+
+            const pk = `f_${key}_${op.slice(1)}`; // e.g. f_title_contains
+            params[pk] =
+              op === "$contains" || op === "$startsWith"
+                ? opValue.toLowerCase() // match the lowercased field
+                : opValue;
+            whereParts.push(builder(key, pk));
+          }
+        }
+      }
+    }
+
+    const where = whereParts.length ? `WHERE ${whereParts.join(" AND ")}` : "";
+    // id/createdAt/updatedAt are always present on every record but aren't part of the
+    // user-defined schema shape (they're injected in create()/update()) — allow sorting by them too.
+    const sortableFields = new Set([...Object.keys(config.schema.shape), "id", "createdAt", "updatedAt"]);
+    const orderBy = sort && sortableFields.has(sort) ? `ORDER BY ${sort} ${order === "desc" ? "DESC" : "ASC"}` : "";
+
+    // Validate populate against known relation fields — prevents FETCH injection
+    const fetchFields =
+      populate === "none"
+        ? []
+        : populate
+          ? populate.filter((f) => relationFieldSet.has(f))
+          : relationFields;
+    const fetch = fetchFields.length ? `FETCH ${fetchFields.join(", ")}` : "";
+    const start = (page - 1) * pageLimit;
+
+    const [data, [countRow]] = await surreal().query<[Returning[], { count: number }[]]>(
+      `SELECT * FROM ${prefix} ${where} ${orderBy} LIMIT ${pageLimit} START ${start} ${fetch};
+       SELECT count() as count FROM ${prefix} ${where} GROUP ALL`,
+      params,
+    );
+
+    const total = countRow?.count ?? 0;
+
+    return {
+      data: data ?? [],
+      meta: {
+        total,
+        page,
+        limit: pageLimit,
+        pageCount: Math.ceil(total / pageLimit),
+      } satisfies ReadMeta,
+    };
+  };
+
+  const show = (id: string) => {
+    let q = surreal().select<Data>(new RecordId(table, id));
+    if (relationFields.length) q = q.fetch(...(relationFields as [string, ...string[]])) as typeof q;
+    return q as unknown as Promise<Returning>;
+  };
+
+  const update = async (id: string, data: Values<Partial<Data>>) => {
+    await assertUnique(data, id);
+
+    return surreal()
+      .update<Data>(new RecordId(table, id))
+      .merge({
+        ...data,
+        updatedAt: moment().toISOString(),
+      }) as unknown as Promise<Returning>;
+  };
+
+  const destroy = (id: string) => {
+    return surreal().delete<Data>(new RecordId(table, id)) as unknown as Promise<Returning>;
+  };
+
+  return {
+    name: config.name,
+    prefix,
+    create,
+    destroy,
+    read,
+    show,
+    table,
+    update,
+    validation: config.schema,
+  };
+};
+
+export * from "./data_type";

package/src/core/module/index.ts

@@ -0,0 +1,12 @@
+export type ModuleReturn = {
+  spin?: () => Promise<void> | void;
+};
+
+export interface Module<Return> {
+  (): Return;
+  init: () => Promise<ModuleReturn> | ModuleReturn;
+}
+
+export const makeModule = <Return>(creator: () => Module<Return>) => {
+  return creator();
+};

package/src/core/path_guard.ts

@@ -0,0 +1,9 @@
+import { join, normalize } from "node:path";
+
+// Resolves `requestedPath` against `baseDir` and rejects anything that escapes it
+// (e.g. "../../etc/passwd") — shared by every module that serves files straight
+// off disk based on a request path (uploads, admin panel SPA, etc).
+export const resolveSafePath = (baseDir: string, requestedPath: string): string | null => {
+  const resolved = normalize(join(baseDir, requestedPath));
+  return resolved.startsWith(baseDir) ? resolved : null;
+};

package/src/models/file.ts

@@ -0,0 +1,17 @@
+import { getConfig } from "../core/config";
+import { makeModel, numeric, text } from "../core/model";
+import z from "zod";
+
+const file = makeModel("file", {
+  name: "File",
+  schema: z.object({
+    meta: getConfig().adapters.file.meta,
+    name: text({ label: "Filename" }),
+    size: numeric({ label: "Size" }),
+    type: text({ label: "Mime Type" }),
+    url: text({ label: "URL" }),
+  }),
+  searchFields: ["name"],
+});
+
+export default file;

package/src/models/user.ts

@@ -0,0 +1,18 @@
+import { email, makeModel, text } from "../core/model";
+import z from "zod";
+
+const user = makeModel("user", {
+  name: "Pengguna",
+  schema: z.object({
+    name: text({ label: "Name" }),
+    email: email({ label: "Email", unique: true }),
+    password: text({ label: "Password" }, (z) =>
+      z.transform((value) => {
+        return Bun.password.hashSync(value);
+      }),
+    ),
+  }),
+  searchFields: ["name", "email"],
+});
+
+export default user;

package/src/modules/admin.ts

@@ -0,0 +1,43 @@
+import { makeModule } from "../core/module";
+import { resolveSafePath } from "../core/path_guard";
+import Elysia from "elysia";
+import { join } from "node:path";
+import elysia from "./elysia";
+
+const adminDir = join(process.cwd(), "_admin");
+const indexFile = () => Bun.file(join(adminDir, "index.html"));
+
+const admin = makeModule(() => {
+  const fn = () => {};
+
+  fn.init = () => {
+    const controller = new Elysia()
+      .get("/_admin", () => indexFile())
+      .get("/_admin/*", async ({ params }) => {
+        // Elysia leaves wildcard params percent-encoded — decode before touching the filesystem.
+        let decoded: string;
+        try {
+          decoded = decodeURIComponent(params["*"]);
+        } catch {
+          return indexFile();
+        }
+
+        const requested = resolveSafePath(adminDir, decoded);
+        if (!requested) return indexFile();
+
+        const file = Bun.file(requested);
+        if (await file.exists()) return file;
+
+        // SPA fallback — let the admin panel's client-side router handle unknown paths.
+        return indexFile();
+      });
+
+    elysia().use(controller);
+
+    return {};
+  };
+
+  return fn;
+});
+
+export default admin;

package/src/modules/analytics.ts

@@ -0,0 +1,212 @@
+import { makeModule } from "../core/module";
+import Elysia from "elysia";
+import geoip from "geoip-lite";
+import moment from "moment";
+import { Table } from "surrealdb";
+import z from "zod";
+import auth from "./auth";
+import elysia from "./elysia";
+import logger from "./logger";
+import surreal from "./surreal";
+
+const table = new Table("pageview");
+
+type TrackInput = {
+  path: string;
+  referrer: string | null;
+  userAgent: string | null;
+  ip: string | null;
+  requestUrl: string;
+};
+
+// Same-origin referrer just means "navigated from another page on this site" —
+// not an actual external traffic source, so it shouldn't be counted as one.
+export const isSameOrigin = (referrer: string | null, requestUrl: string) => {
+  if (!referrer) return false;
+  try {
+    return new URL(referrer).origin === new URL(requestUrl).origin;
+  } catch {
+    return false;
+  }
+};
+
+// `server.requestIP()` only sees the direct TCP peer — behind a reverse proxy
+// (nginx, etc.) that's the proxy itself, not the real visitor. Prefer the
+// headers a trusted proxy sets; fall back to the socket address for direct connections.
+export const resolveClientIp = (
+  request: Request,
+  server: { requestIP: (req: Request) => { address: string } | null } | null,
+) => {
+  const forwardedFor = request.headers.get("x-forwarded-for");
+  if (forwardedFor) return forwardedFor.split(",")[0]!.trim();
+
+  const realIp = request.headers.get("x-real-ip");
+  if (realIp) return realIp.trim();
+
+  return server?.requestIP(request)?.address ?? null;
+};
+
+const hashVisitor = (ip: string, userAgent: string) => {
+  const today = moment().format("YYYY-MM-DD");
+  return new Bun.CryptoHasher("sha256").update(`${ip}:${userAgent}:${today}`).digest("hex");
+};
+
+const lookupCountry = (ip: string | null) => {
+  if (!ip) return null;
+  return geoip.lookup(ip)?.country ?? null;
+};
+
+// from/to must be full ISO datetime strings — createdAt comparison is plain string
+// comparison, and a date-only value ("YYYY-MM-DD") would silently exclude that whole
+// day's records since it sorts before any datetime sharing that prefix.
+const rangeQuery = z.object({
+  from: z.iso.datetime({ offset: true }).optional(),
+  to: z.iso.datetime({ offset: true }).optional(),
+  path: z.coerce.string().optional(),
+});
+
+const buildWhere = (from?: string, to?: string, path?: string) => {
+  const parts: string[] = [];
+  const params: Record<string, unknown> = {};
+
+  if (from) {
+    parts.push("createdAt >= $from");
+    params.from = from;
+  }
+  if (to) {
+    parts.push("createdAt <= $to");
+    params.to = to;
+  }
+  if (path) {
+    parts.push("path = $path");
+    params.path = path;
+  }
+
+  return { where: parts.length ? `WHERE ${parts.join(" AND ")}` : "", params };
+};
+
+const analytics = makeModule(() => {
+  const fn = () => ({
+    track: async ({ path, referrer, userAgent, ip, requestUrl }: TrackInput) => {
+      try {
+        const country = lookupCountry(ip);
+        const visitorHash = ip && userAgent ? hashVisitor(ip, userAgent) : null;
+        const externalReferrer = isSameOrigin(referrer, requestUrl) ? null : referrer;
+
+        await surreal()
+          .create(table)
+          .content({
+            path,
+            referrer: externalReferrer,
+            userAgent,
+            country,
+            visitorHash,
+            createdAt: moment().toISOString(),
+          });
+      } catch (e) {
+        logger().error(e, "[analytics] failed to track pageview");
+      }
+    },
+  });
+
+  fn.init = async () => {
+    const authPlugin = (await auth()).plugin;
+
+    const controller = new Elysia({ prefix: "/api/analytics" })
+      .use(authPlugin)
+      .get(
+        "/summary",
+        async ({ query: { from, to, path } }) => {
+          const { where, params } = buildWhere(from, to, path);
+          const [rows] = await surreal().query<[{ visitorHash: string | null }[]]>(
+            `SELECT visitorHash FROM pageview ${where}`,
+            params,
+          );
+
+          const totalPageviews = rows?.length ?? 0;
+          const uniqueVisitors = new Set((rows ?? []).map((r) => r.visitorHash).filter(Boolean)).size;
+
+          return { data: { totalPageviews, uniqueVisitors } };
+        },
+        { auth: true, query: rangeQuery },
+      )
+      .get(
+        "/by-country",
+        async ({ query: { from, to, path } }) => {
+          const { where, params } = buildWhere(from, to, path);
+          const [rows] = await surreal().query<[{ country: string | null; count: number }[]]>(
+            `SELECT country, count() AS count FROM pageview ${where} GROUP BY country ORDER BY count DESC`,
+            params,
+          );
+
+          return { data: rows ?? [] };
+        },
+        { auth: true, query: rangeQuery },
+      )
+      .get(
+        "/by-referrer",
+        async ({ query: { from, to, path } }) => {
+          const { where, params } = buildWhere(from, to, path);
+          const [rows] = await surreal().query<[{ referrer: string | null; count: number }[]]>(
+            `SELECT referrer, count() AS count FROM pageview ${where} GROUP BY referrer ORDER BY count DESC`,
+            params,
+          );
+
+          return { data: rows ?? [] };
+        },
+        { auth: true, query: rangeQuery },
+      )
+      .get(
+        "/by-page",
+        async ({ query: { from, to } }) => {
+          const { where, params } = buildWhere(from, to, undefined);
+          const [rows] = await surreal().query<[{ path: string; count: number }[]]>(
+            `SELECT path, count() AS count FROM pageview ${where} GROUP BY path ORDER BY count DESC`,
+            params,
+          );
+
+          return { data: rows ?? [] };
+        },
+        {
+          auth: true,
+          query: rangeQuery.omit({ path: true }),
+        },
+      )
+      .get(
+        "/timeseries",
+        async ({ query: { from, to, path, interval } }) => {
+          const { where, params } = buildWhere(from, to, path);
+          const bucketLen = interval === "hour" ? 13 : 10; // "YYYY-MM-DDTHH" vs "YYYY-MM-DD"
+
+          const [rows] = await surreal().query<[{ date: string; count: number }[]]>(
+            `SELECT string::slice(createdAt, 0, ${bucketLen}) AS date, count() AS count
+             FROM pageview ${where}
+             GROUP BY date
+             ORDER BY date ASC`,
+            params,
+          );
+
+          return { data: rows ?? [] };
+        },
+        {
+          auth: true,
+          query: rangeQuery.extend({
+            interval: z.enum(["day", "hour"]).default("day"),
+          }),
+        },
+      );
+
+    elysia().use(controller);
+
+    return {
+      // Runs after surreal's own spin() has connected — init() itself runs too early for DB queries.
+      spin: async () => {
+        await surreal().query("DEFINE TABLE IF NOT EXISTS pageview SCHEMALESS;");
+      },
+    };
+  };
+
+  return fn;
+});
+
+export default analytics;