@njinlabs/njin 0.1.0

package/src/core/banner.ts

@@ -0,0 +1,54 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getConfig } from "./config";
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+};
+
+const PKG_VERSION: string = (() => {
+  try {
+    // Safe to use import.meta.dir here — this looks up njin's OWN version,
+    // not anything project-specific (unlike view.ts's views lookup).
+    return (require(join(import.meta.dir, "../../package.json")) as { version: string }).version;
+  } catch {
+    return "0.0.0";
+  }
+})();
+
+export type BootSummary = {
+  mode: "development" | "production";
+};
+
+// Printed once boot finishes — plain console.log (not pino) on purpose: this is a
+// human-facing startup summary, not a structured log line.
+export const printBanner = ({ mode }: BootSummary): void => {
+  const config = getConfig();
+  const port = config.port;
+  const adminEntry = join(process.cwd(), "_admin", "index.html");
+  const hasAdmin = existsSync(adminEntry);
+
+  const rows: [string, string][] = [
+    ["Local", `http://localhost:${port}`],
+    ["Database", `${config.db.path} ${c.dim}(${config.db.namespace}/${config.db.database})${c.reset}`],
+    ["Models", `${config.models.length} registered`],
+    hasAdmin ? ["Admin", `http://localhost:${port}/_admin`] : ["Admin", `${c.dim}not found — drop a built admin panel into /_admin${c.reset}`],
+  ];
+
+  const label = (text: string) => `${c.dim}${text.padEnd(9)}${c.reset}`;
+
+  const lines = [
+    "",
+    `  ${c.bold}${c.cyan}njin${c.reset} ${c.dim}v${PKG_VERSION}${c.reset}  ${mode === "production" ? c.green : c.yellow}${mode}${c.reset}`,
+    "",
+    ...rows.map(([key, value]) => `  ${c.green}➜${c.reset}  ${label(key)} ${value}`),
+    "",
+  ];
+
+  console.log(lines.join("\n"));
+};

package/src/core/boot.ts

@@ -0,0 +1,10 @@
+import modules from "../config/module";
+import type { ModuleReturn } from "./module";
+
+// Runs every module's spin() in the order config/module.ts defines — boot.ts is the
+// shared implementation behind `njin dev`/`njin start` (and the legacy src/spin.ts entry).
+export const boot = async (): Promise<void> => {
+  for (const module of modules) {
+    if ((module as ModuleReturn).spin) await (module as ModuleReturn).spin!();
+  }
+};

package/src/core/config.ts

@@ -0,0 +1,89 @@
+import type { FileAdapter } from "../modules/file";
+import { join } from "node:path";
+import bunFilesystemAdapter from "./adapters/bun_filesystem";
+import type { makeModel } from "./model";
+
+export type ModelFactory = () => Promise<{ default: ReturnType<typeof makeModel> }>;
+
+export type NjinConfig = {
+  port?: number;
+  db?: {
+    path?: string;
+    namespace?: string;
+    database?: string;
+  };
+  img?: {
+    hosts?: string[];
+  };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  adapters?: {
+    file?: FileAdapter<any>;
+  };
+  models?: ModelFactory[];
+};
+
+export type ResolvedConfig = {
+  port: number;
+  db: { path: string; namespace: string; database: string };
+  img: { hosts: string[] };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  adapters: { file: FileAdapter<any> };
+  models: ModelFactory[];
+};
+
+// Identity function — purely for DX (autocomplete/type-checking on the config
+// object literal), same purpose as Vite's own `defineConfig`.
+export const defineConfig = (config: NjinConfig): NjinConfig => config;
+
+let resolved: ResolvedConfig | null = null;
+
+// Reads `config.ts` from the consuming project's root (process.cwd()) — never
+// from this package's own location, since that would break once this module
+// lives inside node_modules/njin instead of the project itself.
+//
+// `preloaded` lets `njin build` skip the dynamic file read entirely: its generated
+// entry imports the project's config.ts with a static, literal import, which
+// `bun build --compile` can trace and embed directly into the binary. A dynamic
+// import() of a runtime-computed path can't be bundled that way.
+export const loadConfig = async (preloaded?: NjinConfig): Promise<void> => {
+  // Idempotent unless explicitly given a preloaded config: module.ts's own no-arg call is
+  // just a safety net ("ensure config is loaded before any module reads getConfig()") for
+  // njin dev/start, where nothing else loads it first. In a compiled binary, the generated
+  // entry calls loadConfig(config) itself with the real config — without this guard, module.ts's
+  // no-arg call (reached as a side effect of importing it) would otherwise silently clobber that
+  // back to empty defaults.
+  if (!preloaded && resolved) return;
+
+  let userConfig: NjinConfig;
+
+  if (preloaded) {
+    userConfig = preloaded;
+  } else {
+    const path = join(process.cwd(), "config.ts");
+
+    userConfig = {};
+    try {
+      const mod = await import(path);
+      userConfig = mod.default ?? {};
+    } catch {
+      // No config.ts at the project root — run on defaults only.
+    }
+  }
+
+  resolved = {
+    port: userConfig.port ?? 3000,
+    db: {
+      path: userConfig.db?.path ?? "rocksdb://data",
+      namespace: userConfig.db?.namespace ?? "general",
+      database: userConfig.db?.database ?? "general",
+    },
+    img: { hosts: userConfig.img?.hosts ?? [] },
+    adapters: { file: userConfig.adapters?.file ?? bunFilesystemAdapter() },
+    models: userConfig.models ?? [],
+  };
+};
+
+export const getConfig = (): ResolvedConfig => {
+  if (!resolved) throw new Error("Config not loaded yet — loadConfig() must run before getConfig() is called.");
+  return resolved;
+};

package/src/core/http_error.ts

@@ -0,0 +1,21 @@
+export class HttpError extends Error {
+  constructor(
+    public readonly statusCode: number,
+    message?: string,
+  ) {
+    super(message ?? httpStatusMessage(statusCode));
+    this.name = "HttpError";
+  }
+}
+
+function httpStatusMessage(code: number): string {
+  const messages: Record<number, string> = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    422: "Unprocessable Entity",
+    500: "Internal Server Error",
+  };
+  return messages[code] ?? `HTTP Error ${code}`;
+}

package/src/core/model/data_type/array.ts

@@ -0,0 +1,22 @@
+import z from "zod";
+import { type FormMeta } from "..";
+
+export function array<T extends z.ZodTypeAny>(meta: FormMeta, input: T): z.ZodPreprocess<z.ZodArray<T>>;
+
+export function array<T extends z.ZodTypeAny, Z extends z.ZodTypeAny>(meta: FormMeta, input: T, rule: (z: z.ZodArray<T>) => Z): z.ZodPreprocess<Z>;
+
+export function array(meta: FormMeta, input: z.ZodTypeAny, rule?: (z: any) => any) {
+  const baseRule = z.preprocess(
+    (value) => {
+      if (!!value && !Array.isArray(value)) return [value];
+
+      return value;
+    },
+    rule ? rule(z.array(input)) : z.array(input),
+  );
+
+  return baseRule.meta({
+    ...meta,
+    renderAs: "array",
+  });
+}

package/src/core/model/data_type/boolean.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function boolean(meta: FormMeta): z.ZodBoolean;
+
+export function boolean<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodBoolean) => T): T;
+
+export function boolean(meta: FormMeta, rule?: (z: any) => any) {
+  const baseRule = z.boolean();
+
+  return (rule ? rule(baseRule) : baseRule).meta({
+    ...meta,
+    renderAs: "boolean",
+  });
+}

package/src/core/model/data_type/date.ts

@@ -0,0 +1,28 @@
+import moment from "moment";
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function date(meta: FormMeta): z.ZodPreprocess<z.ZodString>;
+
+export function date<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodString) => T): z.ZodPreprocess<T>;
+
+export function date(meta: FormMeta, rule?: (z: any) => any) {
+  const inner = rule ? rule(z.string()) : z.string();
+
+  return z
+    .preprocess((value) => {
+      if (moment.isMoment(value)) {
+        return value.toISOString();
+      }
+
+      if (typeof value === "string") {
+        return moment(value).toISOString();
+      }
+
+      return undefined;
+    }, inner)
+    .meta({
+      ...meta,
+      renderAs: "datepicker",
+    });
+}

package/src/core/model/data_type/email.ts

@@ -0,0 +1,21 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function email(meta: FormMeta): z.ZodPreprocess<z.ZodEmail>;
+
+export function email<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodEmail) => T): z.ZodPreprocess<T>;
+
+export function email(meta: FormMeta, rule?: (z: any) => any) {
+  const inner = rule ? rule(z.email()) : z.email();
+
+  return z
+    .preprocess((value) => {
+      if (!value) return undefined;
+
+      return value;
+    }, inner)
+    .meta({
+      ...meta,
+      renderAs: "text",
+    });
+}

package/src/core/model/data_type/file.ts

@@ -0,0 +1,15 @@
+import fileModule from "../../../modules/file";
+import type z from "zod";
+import { relation, type FormMeta, type RelationType } from "..";
+
+export function file(meta: FormMeta): RelationType<ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>>;
+
+export function file<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: RelationType<ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>>) => T): T;
+
+export function file(meta: FormMeta, rule?: (z: any) => any) {
+  return relation(meta, fileModule().model, rule ? rule : (z) => z).meta({
+    ...meta,
+    renderAs: "file",
+    model: fileModule().model.prefix,
+  });
+}

package/src/core/model/data_type/index.ts

@@ -0,0 +1,13 @@
+export * from "./array";
+export * from "./boolean";
+export * from "./date";
+export * from "./email";
+export * from "./file";
+export * from "./multi_file";
+export * from "./numeric";
+export * from "./object";
+export * from "./relation";
+export * from "./relation_many";
+export * from "./richtext";
+export * from "./select";
+export * from "./text";

package/src/core/model/data_type/multi_file.ts

@@ -0,0 +1,18 @@
+import fileModule from "../../../modules/file";
+import type z from "zod";
+import { type FormMeta, type RelationType } from "..";
+import { relationMany } from "./relation_many";
+
+type Return = RelationType<ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>>;
+
+export function multiFile(meta: FormMeta): z.ZodPreprocess<z.ZodArray<Return>>;
+
+export function multiFile<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodArray<Return>) => T): T;
+
+export function multiFile(meta: FormMeta, rule?: (z: any) => any) {
+  return relationMany(meta, fileModule().model, rule ? rule : (z) => z).meta({
+    ...meta,
+    renderAs: "multi_file",
+    model: fileModule().model.prefix,
+  });
+}

package/src/core/model/data_type/numeric.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function numeric(meta: FormMeta): z.ZodNumber;
+
+export function numeric<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodNumber) => T): T;
+
+export function numeric(meta: FormMeta, rule?: (z: any) => any) {
+  const baseRule = z.number();
+
+  return (rule ? rule(baseRule) : baseRule).meta({
+    ...meta,
+    renderAs: "numeric",
+  });
+}

package/src/core/model/data_type/object.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function object<T extends { [x: string]: z.ZodTypeAny }>(meta: FormMeta, shape: T): z.ZodObject<T>;
+
+export function object<T extends { [x: string]: z.ZodTypeAny }, Z extends z.ZodTypeAny>(meta: FormMeta, shape: T, rule: (z: z.ZodObject<T>) => Z): Z;
+
+export function object(meta: FormMeta, shape: any, rule?: (z: any) => any) {
+  const baseRule = z.object(shape);
+
+  return (rule ? rule(baseRule) : baseRule).meta({
+    ...meta,
+    renderAs: "object",
+  });
+}

package/src/core/model/data_type/relation.ts

@@ -0,0 +1,73 @@
+import { RecordId } from "surrealdb";
+import z from "zod";
+import { type FormMeta, type makeModel } from "..";
+
+export type RelationType<Relation> = z.ZodPreprocess<
+  z.ZodPipe<
+    z.ZodObject<
+      Relation & {
+        id: z.ZodOptional<z.ZodAny>;
+        createdAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodPreprocess<z.ZodString>>;
+        _write: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodBoolean>>>;
+      },
+      z.core.$strip
+    >,
+    z.ZodTransform<
+      | (z.infer<Relation> & {
+          id: unknown;
+          createdAt?: string;
+          updtedAt?: string;
+          _write?: boolean;
+        })
+      | RecordId<string, any>,
+      Relation & {
+        id: unknown;
+        createdAt?: string;
+        updtedAt?: string;
+        _write?: boolean;
+      }
+    >
+  >
+>;
+
+type Relation<Model extends ReturnType<typeof makeModel>> = RelationType<ReturnType<Model["validation"]["partial"]>>;
+
+export function relation<Model extends ReturnType<typeof makeModel>>(meta: FormMeta & { labelKey?: keyof Model["validation"]["shape"] }, model: Model): Relation<Model>;
+
+export function relation<T extends z.ZodTypeAny, Model extends ReturnType<typeof makeModel>>(meta: FormMeta & { labelKey?: keyof Model["validation"]["shape"] }, model: Model, rule: (z: Relation<Model>) => T): T;
+
+export function relation(meta: any, model: ReturnType<typeof makeModel>, rule?: (z: any) => any) {
+  const baseRule = z.preprocess(
+    (value) => {
+      if (typeof value === "string") {
+        return { id: value, _write: true };
+      }
+
+      if (value instanceof RecordId) {
+        return { id: value.toString().split(":")[1], _write: true };
+      }
+
+      return value;
+    },
+    model.validation
+      .extend({
+        id: z.any(),
+        createdAt: z.string(),
+        updatedAt: z.string(),
+        _write: z.boolean(),
+      })
+      .partial()
+      .transform((value) => {
+        if (value._write) return new RecordId(model.table, value.id);
+
+        return value;
+      }),
+  );
+
+  return (rule ? rule(baseRule) : baseRule).meta({
+    ...meta,
+    renderAs: "relation",
+    model: model.prefix,
+  });
+}

package/src/core/model/data_type/relation_many.ts

@@ -0,0 +1,55 @@
+import { RecordId } from "surrealdb";
+import z from "zod";
+import { type FormMeta, type makeModel, type RelationType } from "..";
+
+type Return<Model extends ReturnType<typeof makeModel>> = z.ZodPreprocess<z.ZodArray<RelationType<ReturnType<Model["validation"]["partial"]>>>>;
+
+export function relationMany<Model extends ReturnType<typeof makeModel>>(meta: FormMeta, model: Model): Return<Model>;
+
+export function relationMany<T extends z.ZodTypeAny, Model extends ReturnType<typeof makeModel>>(meta: FormMeta, model: Model, rule: (z: z.ZodArray<RelationType<ReturnType<Model["validation"]["partial"]>>>) => T): T;
+
+export function relationMany(meta: FormMeta, model: ReturnType<typeof makeModel>, rule?: (z: any) => any) {
+  const baseRule = z.array(
+    z.preprocess(
+      (value) => {
+        if (typeof value === "string") {
+          return { id: value, _write: true };
+        }
+
+        if (value instanceof RecordId) {
+          return { id: value.toString().split(":")[1], _write: true };
+        }
+
+        return value;
+      },
+      model.validation
+        .extend({
+          id: z.any(),
+          createdAt: z.string(),
+          updatedAt: z.string(),
+          _write: z.boolean(),
+        })
+        .partial()
+        .transform((value) => {
+          if (value._write) return new RecordId(model.table, value.id);
+
+          return value;
+        }),
+    ),
+  );
+
+  return z
+    .preprocess(
+      (value) => {
+        if (!!value && !Array.isArray(value)) return [value];
+
+        return value;
+      },
+      rule ? rule(baseRule) : baseRule,
+    )
+    .meta({
+      ...meta,
+      renderAs: "multi_relation",
+      model: model.prefix,
+    });
+}

package/src/core/model/data_type/richtext.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function richtext(meta: FormMeta): z.ZodPreprocess<z.ZodString>;
+
+export function richtext<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodString) => T): z.ZodPreprocess<T>;
+
+export function richtext(meta: FormMeta, rule?: (z: any) => any) {
+  const inner = rule ? rule(z.string()) : z.string();
+
+  return z
+    .preprocess((value) => {
+      if (!value) return undefined;
+      return value;
+    }, inner)
+    .meta({
+      ...meta,
+      renderAs: "richtext",
+    });
+}

package/src/core/model/data_type/select.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function select<const T extends readonly string[]>(meta: FormMeta, options: T): z.ZodEnum<{ [x in T[number]]: x }>;
+
+export function select<const T extends readonly string[], Z extends z.ZodTypeAny>(meta: FormMeta, options: T, rule: (z: z.ZodEnum<{ [x in T[number]]: x }>) => Z): Z;
+
+export function select(meta: FormMeta, options: string[], rule?: (z: any) => any) {
+  const baseRule = z.enum(options);
+
+  return (rule ? rule(baseRule) : baseRule).meta({
+    ...meta,
+    renderAs: "select",
+  });
+}

package/src/core/model/data_type/text.ts

@@ -0,0 +1,20 @@
+import z from "zod";
+import type { FormMeta } from "..";
+
+export function text(meta: FormMeta): z.ZodPreprocess<z.ZodString>;
+
+export function text<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodString) => T): z.ZodPreprocess<T>;
+
+export function text(meta: FormMeta, rule?: (z: any) => any) {
+  const inner = rule ? rule(z.string()) : z.string();
+
+  return z
+    .preprocess((value) => {
+      if (!value) return undefined;
+      return value;
+    }, inner)
+    .meta({
+      ...meta,
+      renderAs: "text",
+    });
+}