forge-admin 0.0.0

package/src/orm/core/manager.ts

@@ -0,0 +1,27 @@
+
+// core/manager.ts
+import { QueryBuilder } from "./query-builder";
+
+export class Manager<T> {
+  constructor(private model: new () => T) {}
+
+  create(data: Partial<T>) {
+    return QueryBuilder.insert(this.model, data);
+  }
+
+  update(data: Partial<T>, id: number) {
+    return QueryBuilder.update(this.model, data, id);
+  }
+
+  delete(id:number) {
+    return QueryBuilder.delete(this.model, id);
+  }
+
+  filter(filters: any) {
+    return QueryBuilder.filter(this.model, filters);
+  }
+
+  all() {
+    return QueryBuilder.all(this.model);
+  }
+}

package/src/orm/core/query-builder.ts

@@ -0,0 +1,74 @@
+// core/query-builder.ts
+import { db } from "../db/sqlite";
+import { getModelFields } from "../metadata/model-registry";
+
+export class QueryBuilder {
+
+  static delete(model: any, id: number){
+    model = model.name.toLowerCase();
+    return db
+      .prepare(`DELETE FROM "${model}" WHERE id = ?`)
+      .run(id);
+  }
+
+  static update(model: any, data: any, id: number){
+    const keys = Object.keys(data);
+    model = model.name.toLowerCase();
+    return db.prepare(`
+      UPDATE "${model}"
+      SET ${keys.map(k => `${k} = ?`).join(",")}
+      WHERE id = ?
+    `).run([...Object.values(data), id]);
+  }
+
+  static insert(model: any, data: any) {
+    model = model.name.toLowerCase();
+    const modelFields = getModelFields(model);
+
+     const finalData = { ...data };
+     for (const field of modelFields.fields) {
+      if (
+        field.type === "datetime" &&
+        field.options?.autoNowAdd &&
+        finalData[field.name] == null
+      ) {
+        finalData[field.name] = Date.now();
+      }
+    }
+    const keys = Object.keys(finalData);
+    const values = Object.values(finalData);
+    const sql = `
+      INSERT INTO ${model}
+      (${keys.join(",")})
+      VALUES (${keys.map(() => "?").join(",")})
+    `;
+
+    db.prepare(sql).run(values);
+  }
+
+  static all(model: any) {
+    model = model.name.toLowerCase();
+    const sql = `SELECT * FROM ${model};`;
+    return db.prepare(sql).all();
+  }
+
+  static async filter(model: any, filters: any) {
+
+    const clauses: string[] = [];
+    const values: any[] = [];
+
+    for (const key in filters) {
+      if (key.endsWith("__icontains")) {
+        const field = key.replace("__icontains", "");
+        clauses.push(`${field} LIKE ?`);
+        values.push(`%${filters[key]}%`);
+      } else {
+        clauses.push(`${key} = ?`);
+        values.push(filters[key]);
+      }
+    }
+
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    return db.prepare(`SELECT * FROM ${model} ${where}`).all(values);
+  }
+}

package/src/orm/db/sql-types.ts

@@ -0,0 +1,72 @@
+// orm/db/sql-types.ts
+import { FieldMeta } from "../metadata/types";
+import { SQLiteTypeMap } from "../metadata/types";
+import { fieldModifiers } from "../metadata/modifiers";
+import { IndexMeta } from "../metadata";
+
+export function fieldToSQL(
+  field: FieldMeta,
+): string {
+  const typeMap = SQLiteTypeMap;
+  const typeFn = typeMap[field.type];
+
+  if (field.type === "foreignkey") {
+    const mods = [];
+
+    if (!field.options?.nullable) mods.push("NOT NULL");
+
+    return ["INTEGER", ...mods].join(" ");
+  }
+  if (!typeFn) {
+    throw new Error(`Unsupported field type: ${field.type}`);
+  }
+
+  const sqlType = typeFn(field);
+  const modifiers = fieldModifiers(field);
+
+  return [sqlType, modifiers].filter(Boolean).join(" ");
+}
+
+
+export function foreignKeyToSQL(field: FieldMeta): string | null {
+  if (field.type !== "foreignkey") return null;
+
+  const { to, toField, onDelete } = field.options ?? {};
+
+  if (!to || !toField) {
+    throw new Error(`ForeignKey field "${field.name}" missing 'to' or 'toField'`);
+  }
+
+  const clauses = [
+    `FOREIGN KEY (${field.name})`,
+    `REFERENCES ${to}(${toField})`,
+  ];
+
+  if (onDelete) {
+    clauses.push(`ON DELETE ${onDelete}`);
+  }
+
+  return clauses.join(" ");
+}
+
+
+// orm/db/sql/index.ts
+export function createIndexSQL(
+  table: string,
+  index: IndexMeta
+) {
+  const name = index.name;
+  const fields = index.fields.map(f => `"${f}"`).join(", ");
+
+  return `
+    CREATE ${index.unique ? "UNIQUE" : ""} INDEX "${name}"
+    ON "${table}" (${fields});
+  `;
+}
+
+export function dropIndexSQL(
+  table: string,
+  index: IndexMeta
+) {
+  return `DROP INDEX "${index.name}";`;
+}

package/src/orm/db/sqlite.ts

@@ -0,0 +1,4 @@
+// db/sqlite.ts
+import Database from "better-sqlite3";
+
+export const db = new Database("app.db");

package/src/orm/decorators/field.ts

@@ -0,0 +1,80 @@
+// orm/decorators/fields.ts
+import { MODEL_META } from "../metadata/keys";
+import type { ModelMeta } from "../metadata/types";
+import { registerField } from "../metadata/model-registry";
+
+function getOrCreateMeta(metadata: any): ModelMeta {
+  if (!metadata[MODEL_META]) {
+    metadata[MODEL_META] = {
+      tableName: "",   // set later by @Model
+      fields: [],
+    };
+  }
+  return metadata[MODEL_META];
+}
+
+export function PrimaryKey(className: string) {
+  return function (_: undefined, context: ClassFieldDecoratorContext) {
+    const meta = getOrCreateMeta(context.metadata);
+    meta.fields.push({
+      name: context.name as string,
+      type: "primary",
+    });
+    meta.primaryKey = context.name as string;
+    registerField(className.toLowerCase(), { name: context.name as string, type: "primary",})
+  };
+}
+
+export function CharField(className: string, options: { maxLength: number }) {
+  return function (_: undefined, context: ClassFieldDecoratorContext) {
+    const meta = getOrCreateMeta(context.metadata);
+
+    meta.fields.push({
+      name: context.name as string,
+      type: "string",
+      options,
+    });
+    registerField(className.toLowerCase(), { name: context.name as string, type: "string", options})
+  };
+}
+
+export function EmailField(className: string, options: {}) {
+  return function (_: undefined, context: ClassFieldDecoratorContext) {
+    const meta = getOrCreateMeta(context.metadata);
+
+    meta.fields.push({
+      name: context.name as string,
+      type: "email",
+      options
+    });
+    registerField(className.toLowerCase(), { name: context.name as string, type: "string", options})
+
+  };
+}
+
+export function DateTimeField(className: string, options?: { autoNowAdd?: boolean }) {
+  return function (_: undefined, context: ClassFieldDecoratorContext) {
+    const meta = getOrCreateMeta(context.metadata);
+
+    meta.fields.push({
+      name: context.name as string,
+      type: "datetime",
+      options,
+    });
+    registerField(className.toLowerCase(), { name: context.name as string, type: "datetime", options})
+  };
+}
+
+
+export function ForgeinKey(className: string, options?: {}){
+  return function (_: undefined, context: ClassFieldDecoratorContext) {
+    const meta = getOrCreateMeta(context.metadata);
+     meta.fields.push({
+      name: context.name as string,
+      type: "foreignkey",
+      options,
+    });
+    registerField(className.toLowerCase(), { name: context.name as string, type: "foreignkey", options})
+    
+  }
+}

package/src/orm/decorators/model.ts

@@ -0,0 +1,36 @@
+// decorators/model.ts
+import { MODEL_META } from "../metadata/keys";
+import type { ModelMeta } from "../metadata/types";
+import { Manager } from "../core/manager";
+import { registerModel } from "../metadata/model-registry";
+
+export function Model(options?: { tableName?: string }) {
+  return function <T extends { new (...args: any[]): {} }>(
+    constructor: T,
+    context: ClassDecoratorContext
+  ) {
+    context.addInitializer(() => {
+      let meta: ModelMeta = {
+        tableName: options?.tableName ?? constructor.name.toLowerCase(),
+        fields: [],
+      };
+
+       if (!meta) {
+        meta = {
+          tableName: constructor.name.toLowerCase(),
+          fields: [],
+        };
+        constructor[MODEL_META] = meta;
+      }
+
+      // attach metadata to constructor
+      (constructor as any)[MODEL_META] = meta;
+      
+      meta.tableName = options?.tableName ?? constructor.name.toLowerCase();
+      // Django-style manager
+      (constructor as any).objects = new Manager(constructor);
+
+      registerModel(constructor); // 🔑 CRITICAL
+    });
+  };
+}

package/src/orm/metadata/field-types.ts

@@ -0,0 +1,12 @@
+// orm/metadata/field-types.ts
+export type FieldType =
+  | "primary"
+  | "string"
+  | "text"
+  | "email"
+  | "number"
+  | "boolean"
+  | "datetime"
+  | "date"
+  | "json"
+  | "foreignkey";

package/src/orm/metadata/get-meta.ts

@@ -0,0 +1,9 @@
+// metadata/get-meta.ts
+import { MODEL_META } from "./keys";
+import type { ModelMeta } from "./types";
+
+export function getModelMeta(model: any): ModelMeta {
+  const meta = model[MODEL_META];
+  if (!meta) throw new Error("Model metadata not found");
+  return meta;
+}

package/src/orm/metadata/index.ts

@@ -0,0 +1,15 @@
+// orm/metadata/index.ts
+export interface IndexMeta {
+  name: string;              // deterministic name
+  fields: string[];          // ordered
+  unique?: boolean;
+}
+
+
+export function indexName(
+  table: string,
+  fields: string[],
+  unique?: boolean
+) {
+  return `${table}_${fields.join("_")}${unique ? "_uniq" : "_idx"}`;
+}

package/src/orm/metadata/keys.ts

@@ -0,0 +1,2 @@
+// orm/metadata/keys.ts
+export const MODEL_META = Symbol.for("orm:model_meta");

package/src/orm/metadata/model-registry.ts

@@ -0,0 +1,53 @@
+// metadata/model-registry.ts
+import { ModelMeta } from "./types";
+
+class ModelRegistry {
+  models = new Map<Function, ModelMeta>();
+
+  registerModel(target: Function, meta: ModelMeta) {
+    this.models.set(target, meta);
+  }
+
+  getModel(target: Function) {
+    return this.models.get(target);
+  }
+}
+
+export const modelRegistry = new ModelRegistry();
+
+
+const MODEL_REGISTRY = new Map<string, any>();
+
+
+export function registerModel(model: any) {
+  MODEL_REGISTRY.set(model.name.toLowerCase(), model);
+}
+
+export function getAllModels() {
+  return Array.from(MODEL_REGISTRY.values());
+}
+
+
+
+
+const MODEL_META = new Map<string, any>();
+
+export function registerField(modelName: string, field: any) {
+    let modelMeta = MODEL_META.get(modelName)
+
+    if(!modelMeta) {
+        modelMeta = {
+            fields: []
+        }
+    }
+    modelMeta.fields.push(field)
+    MODEL_META.set(modelName, modelMeta)
+}
+
+export function getModelByName(modelName) {
+  return MODEL_REGISTRY.get(modelName);
+}
+
+export function getModelFields(modelName: string) {
+    return MODEL_META.get(modelName)
+}

package/src/orm/metadata/modifiers.ts

@@ -0,0 +1,26 @@
+// orm/db/sql/modifiers.ts
+import { FieldMeta } from "./types";
+
+export function fieldModifiers(
+  field: FieldMeta
+): string {
+  const mods: string[] = [];
+
+  if (!field.nullable) {
+    mods.push("NOT NULL");
+  }
+
+  if (field.default !== undefined) {
+    if (field.default === "now") {
+        "DEFAULT CURRENT_TIMESTAMP";
+    } else {
+      mods.push(`DEFAULT ${JSON.stringify(field.default)}`);
+    }
+  }
+
+  if (field.options?.unique) {
+    mods.push("UNIQUE");
+  }
+
+  return mods.join(" ");
+}

package/src/orm/metadata/types.ts

@@ -0,0 +1,45 @@
+export type ModelMeta = {
+  tableName: string;
+  fields: FieldMeta[];
+  primaryKey?: string;
+  indexes: {};
+  constraints: {};
+};
+
+// orm/metadata/types.ts
+import { FieldType } from "./field-types";
+
+export interface FieldMeta {
+  name: string;
+  type: FieldType;
+  nullable?: boolean;
+  default?: any;
+  options?: {
+    maxLength?: number;
+    autoNowAdd?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    nullable?: boolean;
+    default?: any;
+    // FK
+    to?: string;
+    field?: string;
+    toField?: string
+    onDelete?: "CASCADE" | "SET NULL" | "RESTRICT";
+  };
+}
+
+
+// orm/db/sqlite/types.ts
+export const SQLiteTypeMap: Record<string, (f: FieldMeta) => string> = {
+  primary: () => `INTEGER PRIMARY KEY AUTOINCREMENT`,
+  string: f => `VARCHAR(${f.options?.maxLength ?? 255})`,
+  email: () => `VARCHAR(255)`,
+  text: () => `TEXT`,
+  number: () => `INTEGER`,
+  boolean: () => `BOOLEAN`,
+  datetime: () => `DATETIME`,
+  date: () => `DATE`,
+  json: () => `TEXT`,
+  foreignkey: ()=> `FOREIGN KEY`,
+};