forge-admin 0.0.0

package/src/hooks/use-toast.ts

@@ -0,0 +1,186 @@
+import * as React from "react";
+
+import type { ToastActionElement, ToastProps } from "@/components/ui/toast";
+
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+
+type ToasterToast = ToastProps & {
+  id: string;
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  action?: ToastActionElement;
+};
+
+const actionTypes = {
+  ADD_TOAST: "ADD_TOAST",
+  UPDATE_TOAST: "UPDATE_TOAST",
+  DISMISS_TOAST: "DISMISS_TOAST",
+  REMOVE_TOAST: "REMOVE_TOAST",
+} as const;
+
+let count = 0;
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER;
+  return count.toString();
+}
+
+type ActionType = typeof actionTypes;
+
+type Action =
+  | {
+      type: ActionType["ADD_TOAST"];
+      toast: ToasterToast;
+    }
+  | {
+      type: ActionType["UPDATE_TOAST"];
+      toast: Partial<ToasterToast>;
+    }
+  | {
+      type: ActionType["DISMISS_TOAST"];
+      toastId?: ToasterToast["id"];
+    }
+  | {
+      type: ActionType["REMOVE_TOAST"];
+      toastId?: ToasterToast["id"];
+    };
+
+interface State {
+  toasts: ToasterToast[];
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>();
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId: toastId,
+    });
+  }, TOAST_REMOVE_DELAY);
+
+  toastTimeouts.set(toastId, timeout);
+};
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      };
+
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map((t) => (t.id === action.toast.id ? { ...t, ...action.toast } : t)),
+      };
+
+    case "DISMISS_TOAST": {
+      const { toastId } = action;
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId);
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id);
+        });
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t,
+        ),
+      };
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        };
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      };
+  }
+};
+
+const listeners: Array<(state: State) => void> = [];
+
+let memoryState: State = { toasts: [] };
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((listener) => {
+    listener(memoryState);
+  });
+}
+
+type Toast = Omit<ToasterToast, "id">;
+
+function toast({ ...props }: Toast) {
+  const id = genId();
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: "UPDATE_TOAST",
+      toast: { ...props, id },
+    });
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss();
+      },
+    },
+  });
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  };
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState);
+
+  React.useEffect(() => {
+    listeners.push(setState);
+    return () => {
+      const index = listeners.indexOf(setState);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }, [state]);
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+  };
+}
+
+export { useToast, toast };

package/src/index.css

@@ -0,0 +1,142 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Inter:wght@400;500;600;700&display=swap');
+
+@layer base {
+  :root {
+    --background: 222 47% 6%;
+    --foreground: 210 40% 98%;
+
+    --card: 222 47% 8%;
+    --card-foreground: 210 40% 98%;
+
+    --popover: 222 47% 10%;
+    --popover-foreground: 210 40% 98%;
+
+    --primary: 173 80% 40%;
+    --primary-foreground: 222 47% 6%;
+
+    --secondary: 222 47% 12%;
+    --secondary-foreground: 210 40% 98%;
+
+    --muted: 222 47% 14%;
+    --muted-foreground: 215 20% 55%;
+
+    --accent: 173 80% 40%;
+    --accent-foreground: 222 47% 6%;
+
+    --destructive: 0 62% 50%;
+    --destructive-foreground: 210 40% 98%;
+
+    --border: 222 47% 16%;
+    --input: 222 47% 14%;
+    --ring: 173 80% 40%;
+
+    --radius: 0.5rem;
+
+    --sidebar-background: 222 47% 5%;
+    --sidebar-foreground: 210 40% 80%;
+    --sidebar-primary: 173 80% 40%;
+    --sidebar-primary-foreground: 222 47% 6%;
+    --sidebar-accent: 222 47% 10%;
+    --sidebar-accent-foreground: 210 40% 98%;
+    --sidebar-border: 222 47% 12%;
+    --sidebar-ring: 173 80% 40%;
+
+    /* Custom tokens */
+    --success: 142 76% 36%;
+    --success-foreground: 210 40% 98%;
+    --warning: 38 92% 50%;
+    --warning-foreground: 222 47% 6%;
+    --info: 199 89% 48%;
+    --info-foreground: 222 47% 6%;
+
+    --font-mono: 'JetBrains Mono', monospace;
+    --font-sans: 'Inter', system-ui, sans-serif;
+  }
+
+  .dark {
+    --background: 222 47% 6%;
+    --foreground: 210 40% 98%;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+
+  body {
+    @apply bg-background text-foreground font-sans antialiased;
+    font-family: var(--font-sans);
+  }
+
+  code, pre, .font-mono {
+    font-family: var(--font-mono);
+  }
+}
+
+@layer components {
+  .admin-card {
+    @apply bg-card border border-border rounded-lg p-4 transition-all duration-200;
+  }
+
+  .admin-card:hover {
+    @apply border-primary/30;
+  }
+
+  .stat-card {
+    @apply admin-card relative overflow-hidden;
+  }
+
+  .stat-card::before {
+    content: '';
+    @apply absolute top-0 left-0 w-1 h-full bg-primary;
+  }
+
+  .model-badge {
+    @apply inline-flex items-center px-2 py-0.5 rounded text-xs font-medium font-mono;
+  }
+
+  .field-type-string {
+    @apply bg-info/20 text-info;
+  }
+
+  .field-type-number {
+    @apply bg-warning/20 text-warning;
+  }
+
+  .field-type-boolean {
+    @apply bg-success/20 text-success;
+  }
+
+  .field-type-date {
+    @apply bg-primary/20 text-primary;
+  }
+
+  .glow-effect {
+    box-shadow: 0 0 20px hsl(var(--primary) / 0.15);
+  }
+}
+
+@layer utilities {
+  .scrollbar-thin {
+    scrollbar-width: thin;
+    scrollbar-color: hsl(var(--muted)) transparent;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar {
+    width: 6px;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar-track {
+    background: transparent;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar-thumb {
+    background-color: hsl(var(--muted));
+    border-radius: 3px;
+  }
+}

package/src/lib/models.ts

@@ -0,0 +1,138 @@
+// ORM-like model definitions
+
+export type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'text' | 'email' | 'select';
+
+export interface FieldDefinition {
+  name: string;
+  type: FieldType;
+  label: string;
+  required?: boolean;
+  default?: unknown;
+  options?: string[]; // for select type
+  maxLength?: number;
+}
+
+export interface ModelDefinition {
+  name: string;
+  displayName: string;
+  icon: string;
+  fields: FieldDefinition[];
+  primaryKey: string;
+}
+
+// Define your models here (like Django models)
+export const models: ModelDefinition[] = [
+  {
+    name: 'users',
+    displayName: 'Users',
+    icon: 'Users',
+    primaryKey: 'id',
+    fields: [
+      { name: 'id', type: 'number', label: 'ID', required: true },
+      { name: 'username', type: 'string', label: 'Username', required: true, maxLength: 50 },
+      { name: 'email', type: 'email', label: 'Email', required: true },
+      { name: 'role', type: 'select', label: 'Role', options: ['admin', 'user', 'editor'], default: 'user' },
+      { name: 'is_active', type: 'boolean', label: 'Active', default: true },
+      { name: 'created_at', type: 'date', label: 'Created At' },
+    ],
+  },
+  {
+    name: 'posts',
+    displayName: 'Posts',
+    icon: 'FileText',
+    primaryKey: 'id',
+    fields: [
+      { name: 'id', type: 'number', label: 'ID', required: true },
+      { name: 'title', type: 'string', label: 'Title', required: true, maxLength: 200 },
+      { name: 'content', type: 'text', label: 'Content' },
+      { name: 'author_id', type: 'number', label: 'Author ID', required: true },
+      { name: 'published', type: 'boolean', label: 'Published', default: false },
+      { name: 'created_at', type: 'date', label: 'Created At' },
+    ],
+  },
+  {
+    name: 'products',
+    displayName: 'Products',
+    icon: 'Package',
+    primaryKey: 'id',
+    fields: [
+      { name: 'id', type: 'number', label: 'ID', required: true },
+      { name: 'name', type: 'string', label: 'Name', required: true },
+      { name: 'price', type: 'number', label: 'Price', required: true },
+      { name: 'category', type: 'select', label: 'Category', options: ['electronics', 'clothing', 'food', 'other'] },
+      { name: 'in_stock', type: 'boolean', label: 'In Stock', default: true },
+      { name: 'created_at', type: 'date', label: 'Created At' },
+    ],
+  },
+  {
+    name: 'orders',
+    displayName: 'Orders',
+    icon: 'ShoppingCart',
+    primaryKey: 'id',
+    fields: [
+      { name: 'id', type: 'number', label: 'ID', required: true },
+      { name: 'user_id', type: 'number', label: 'User ID', required: true },
+      { name: 'total', type: 'number', label: 'Total', required: true },
+      { name: 'status', type: 'select', label: 'Status', options: ['pending', 'processing', 'shipped', 'delivered', 'cancelled'] },
+      { name: 'created_at', type: 'date', label: 'Created At' },
+    ],
+  },
+  {
+    name: 'table',
+    displayName: 'Table',
+    primaryKey: 'id',
+    fields: [
+      { name: 'id', type: 'number', label: 'ID', required: true },
+      { name: 'name', type: 'string', label: 'Name', required: true },
+    ],
+    icon: ""
+  }
+];
+
+export function getModel(name: string): ModelDefinition | undefined {
+  return models.find(m => m.name === name);
+}
+
+// Generate mock data for a model
+export function generateMockData(model: ModelDefinition, count: number = 10): Record<string, unknown>[] {
+  const data: Record<string, unknown>[] = [];
+  
+  for (let i = 1; i <= count; i++) {
+    const record: Record<string, unknown> = {};
+    
+    for (const field of model.fields) {
+      switch (field.type) {
+        case 'number':
+          record[field.name] = field.name === 'id' ? i : 
+            field.name.includes('price') || field.name.includes('total') ? 
+            Math.floor(Math.random() * 1000) + 10 : 
+            Math.floor(Math.random() * 100) + 1;
+          break;
+        case 'string':
+        case 'text':
+          record[field.name] = `${field.label} ${i}`;
+          break;
+        case 'email':
+          record[field.name] = `user${i}@example.com`;
+          break;
+        case 'boolean':
+          record[field.name] = Math.random() > 0.3;
+          break;
+        case 'date':
+          const date = new Date();
+          date.setDate(date.getDate() - Math.floor(Math.random() * 30));
+          record[field.name] = date.toISOString().split('T')[0];
+          break;
+        case 'select':
+          if (field.options && field.options.length > 0) {
+            record[field.name] = field.options[Math.floor(Math.random() * field.options.length)];
+          }
+          break;
+      }
+    }
+    
+    data.push(record);
+  }
+  
+  return data;
+}

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/main.tsx

@@ -0,0 +1,5 @@
+import { createRoot } from "react-dom/client";
+import App from "./App.tsx";
+import "./index.css";
+
+createRoot(document.getElementById("root")!).render(<App />);

package/src/orm/cli/makemigrations.ts

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+import { diffStates } from "../migration-engine/diff";
+import { buildSchemaState } from "../schema/build";
+import { loadState } from "../schema/state";
+import { reverseOp } from "../schema/build";
+
+export function makemigrations() {
+
+    const migrationsDir = path.resolve(
+        process.cwd(),
+        "migrations"
+    );
+
+    // 🔑 ENSURE DIRECTORY EXISTS
+    fs.mkdirSync(migrationsDir, { recursive: true });
+
+    const prevState = loadState();
+
+    const currentState = buildSchemaState();
+   
+    const ops = diffStates(prevState, currentState);
+
+    const destructiveOps = ops.filter(op =>
+    ["DropTable", "RemoveColumn"].includes(op.type)
+    );
+
+    if (destructiveOps.length) {
+    console.warn(
+        "\n⚠️ Destructive changes detected:\n",
+        destructiveOps
+    );
+    console.warn(
+        "These operations will NOT be applied automatically."
+    );
+    }
+
+    if (ops.length === 0) {
+        console.log("No changes detected");
+        return;
+    }
+
+    const filename = `${process.cwd()}/migrations/${Date.now()}_auto.ts`;
+
+    const up = ops;
+    const down = [...up].reverse().map(reverseOp);
+
+
+    fs.writeFileSync(
+    filename,
+    `export default {
+        up: ${JSON.stringify(up, null, 2)},
+        down: ${JSON.stringify(down, null, 2)}
+    };`
+    );
+
+    fs.writeFileSync(
+        `${process.cwd()}/migrations/_state.json`,
+        JSON.stringify(currentState, null, 2)
+    );
+
+    console.log(`Created migration ${filename}`);
+}

package/src/orm/cli/migrate.ts

@@ -0,0 +1,127 @@
+import fs from "fs";
+import path from "path";
+import { db } from "../db/sqlite";
+import { opToSQL } from "../migration-engine/operations";
+import { requiresRebuild, introspectTable, rebuildTable, applyOpToSchema } from "../migration-engine/operations";
+
+
+async function applyMigration(file: string) {
+  const mod = await importMigration(file);
+  for (const op of mod.up) {
+    if (requiresRebuild(op)) {
+      const oldState = introspectTable(op.model);
+      const newState = applyOpToSchema(oldState, op);
+      const sqlStatements = rebuildTable(
+        op.model,
+        oldState,
+        newState
+      );
+
+      db.transaction(() => {
+        for (const sql of sqlStatements) {
+          console.log(sql);
+          db.exec(sql);
+        }
+      })();
+    } 
+    else 
+    {
+      const sql = opToSQL(op);
+      if (sql) db.exec(sql);
+    }  
+  }
+
+  db.prepare(
+    `INSERT INTO orm_migrations VALUES (?, ?)`
+  ).run(file, Date.now());
+
+  console.log(`Applied ${file}`);
+}
+
+async function rollbackMigration(file: string) {
+  const mod = await importMigration(file);
+
+  for (const op of mod.down) {
+    if (requiresRebuild(op)) {
+      const oldState = introspectTable(op.table);
+      const newState = applyOpToSchema(oldState, op);
+
+      const sqlStatements = rebuildTable(
+        op.table,
+        oldState,
+        newState
+      );
+
+      db.transaction(() => {
+        for (const sql of sqlStatements) {
+          db.exec(sql);
+        }
+      })();
+    } 
+    else 
+    {
+      const sql = opToSQL(op);
+      if (sql) db.exec(sql);
+    }  
+  }
+
+  db.prepare(
+    `DELETE FROM orm_migrations WHERE name = ?`
+  ).run(file);
+
+  console.log(`Rolled back ${file}`);
+}
+
+async function importMigration(file: string) {
+  const modulePath = new URL(
+    `${process.cwd()}/migrations/${file}`,
+    import.meta.url
+  ).href;
+
+  return (await import(modulePath)).default;
+}
+
+
+export async function migrate({ to }: { to?: string } = {}) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS orm_migrations (
+      name TEXT PRIMARY KEY,
+      applied_at INTEGER
+    );
+  `);
+
+  const applied = db
+    .prepare(`SELECT name FROM orm_migrations ORDER BY applied_at`)
+    .all()
+    .map((r: any) => r.name);
+
+  const migrationsDir = path.resolve(`${process.cwd()}/migrations`);
+
+  const allFiles = fs
+    .readdirSync(migrationsDir)
+    .filter(f => f.endsWith(".ts") && f !== "_state.json")
+    .sort();
+
+  // DEFAULT: migrate all up
+  if (!to) {
+    for (const file of allFiles) {
+      if (applied.includes(file)) continue;
+      await applyMigration(file);
+    }
+    return;
+  }
+
+  // ROLLBACK
+  if (to === "zero") {
+    for (const file of applied.reverse()) {
+      await rollbackMigration(file);
+    }
+    return;
+  }
+
+  // ROLLBACK TO TARGET
+  for (const file of applied.reverse()) {
+    if (file === to) break;
+    await rollbackMigration(file);
+  }
+}

package/src/orm/cli.ts

@@ -0,0 +1,30 @@
+// src/orm/cli.ts
+import "../models"
+import { makemigrations } from "./cli/makemigrations";
+import { migrate } from "./cli/migrate";
+
+// IMPORTANT: import models so decorators run
+import "../models";
+
+const command = process.argv[2];
+const to = process.argv[3];
+
+switch (command) {
+  case "makemigrations":
+    makemigrations();
+    break;
+
+  case "migrate":
+    migrate({ to });
+    break;
+
+  default:
+    console.error(`
+Unknown command: ${command}
+
+Usage:
+  npm run orm makemigrations
+  npm run orm migrate
+`);
+    process.exit(1);
+}

package/src/orm/core/base-model.ts

@@ -0,0 +1,6 @@
+// core/base-model.ts
+import { Manager } from "./manager";
+
+export abstract class BaseModel {
+  static objects: Manager<any>;
+}