@shadow-dev/orm 1.0.3 → 2.0.0

package/dist/core/Database.d.ts

@@ -1,6 +1,15 @@
 import mysql from "mysql2/promise";
-import { Model } from "./Model";
-export declare function initDatabase(config: mysql.PoolOptions): void;
+import { Model } from "./Model.js";
+export declare function initDatabase(config: mysql.PoolOptions, options?: {
+    migrations?: {
+        path: string;
+        auto?: boolean;
+    };
+}): Promise<void>;
 export declare function getPool(): mysql.Pool;
 export declare function registerModel<T>(model: Model<T>): void;
 export declare function getAllModels(): Map<string, Model<any>>;
+export declare function exec(sql: string, params?: any[]): Promise<mysql.QueryResult>;
+export declare function query<T = any>(sql: string, params?: any[]): Promise<T>;
+export declare function transaction<T>(fn: (conn: mysql.PoolConnection) => Promise<T>): Promise<T>;
+export declare function runMigrations(dir: string): Promise<void>;

package/dist/core/Database.js

@@ -1,28 +1,111 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initDatabase = initDatabase;
-exports.getPool = getPool;
-exports.registerModel = registerModel;
-exports.getAllModels = getAllModels;
 // Database.ts
-const promise_1 = __importDefault(require("mysql2/promise"));
+import mysql from "mysql2/promise";
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
 let pool;
 const modelRegistry = new Map();
-function initDatabase(config) {
-    pool = promise_1.default.createPool(config);
+let migrationsPath = null;
+let autoMigrate = false;
+/* ---------------------------------- */
+/* Initialization                      */
+/* ---------------------------------- */
+export async function initDatabase(config, options) {
+    pool = mysql.createPool(config);
+    if (options?.migrations) {
+        migrationsPath = options.migrations.path;
+        autoMigrate = options.migrations.auto ?? false;
+    }
+    if (autoMigrate && migrationsPath) {
+        await runMigrations(migrationsPath);
+    }
 }
-function getPool() {
+export function getPool() {
     if (!pool)
         throw new Error("Database not initialized");
     return pool;
 }
+/* ---------------------------------- */
+/* Models                              */
+/* ---------------------------------- */
 // @ts-expect-error wierd generic errors
-function registerModel(model) {
+export function registerModel(model) {
     modelRegistry.set(model.name, model);
 }
-function getAllModels() {
+export function getAllModels() {
     return modelRegistry;
 }
+/* ---------------------------------- */
+/* Low-level helpers                   */
+/* ---------------------------------- */
+export async function exec(sql, params) {
+    const [result] = await getPool().execute(sql, params);
+    return result;
+}
+export async function query(sql, params) {
+    const [rows] = await getPool().query(sql, params);
+    return rows;
+}
+export async function transaction(fn) {
+    const conn = await getPool().getConnection();
+    try {
+        await conn.beginTransaction();
+        const result = await fn(conn);
+        await conn.commit();
+        return result;
+    }
+    catch (err) {
+        await conn.rollback();
+        throw err;
+    }
+    finally {
+        conn.release();
+    }
+}
+/* ---------------------------------- */
+/* Migrations                          */
+/* ---------------------------------- */
+async function ensureMigrationTable() {
+    await exec(`
+    CREATE TABLE IF NOT EXISTS shadoworm_migrations (
+      id VARCHAR(255) PRIMARY KEY,
+      name VARCHAR(255) NOT NULL,
+      executed_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+}
+async function loadMigrations(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs
+        .readdirSync(dir)
+        .filter(f => f.endsWith(".js") || f.endsWith(".ts"));
+    const migrations = [];
+    for (const file of files) {
+        const fullPath = path.resolve(dir, file);
+        const fileUrl = pathToFileURL(fullPath).href;
+        const mod = await import(fileUrl);
+        if (!mod.migration) {
+            throw new Error(`Migration ${file} does not export 'migration'`);
+        }
+        migrations.push(mod.migration);
+    }
+    return migrations.sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function runMigrations(dir) {
+    await ensureMigrationTable();
+    const applied = await query(`SELECT id FROM shadoworm_migrations`);
+    const appliedIds = new Set(applied.map(m => m.id));
+    const migrations = await loadMigrations(dir);
+    for (const migration of migrations) {
+        if (appliedIds.has(migration.id))
+            continue;
+        await transaction(async (conn) => {
+            await migration.up({
+                exec: (sql, params) => conn.execute(sql, params),
+                query: (sql, params) => conn.query(sql, params).then(([rows]) => rows)
+            });
+            await conn.execute(`INSERT INTO shadoworm_migrations (id, name) VALUES (?, ?)`, [migration.id, migration.name]);
+        });
+    }
+}

package/dist/core/Migration.d.ts

@@ -0,0 +1,10 @@
+export interface Migration {
+    id: string;
+    name: string;
+    up(db: MigrationContext): Promise<void> | void;
+    down?: (db: MigrationContext) => Promise<void> | void;
+}
+export interface MigrationContext {
+    exec(sql: string, params?: any[]): Promise<any>;
+    query<T = any>(sql: string, params?: any[]): Promise<T>;
+}

package/dist/core/Migration.js

@@ -0,0 +1 @@
+export {};

package/dist/core/Model.d.ts

@@ -3,22 +3,37 @@ export interface BaseSchema {
     data?: any;
     createdAt?: Date;
 }
-export interface ForeignKeyDefinition {
-    column: string;
-    reference: string;
-}
 export type SimpleFieldType = "string" | "int" | "float" | "boolean" | "json" | "datetime";
 export interface FieldOptions {
     type: SimpleFieldType;
     pk?: boolean;
+    autoIncrement?: boolean;
     required?: boolean;
+    unique?: boolean;
     default?: any;
 }
+export interface IndexDefinition {
+    name?: string;
+    columns: string[];
+    unique?: boolean;
+}
 export type SchemaValue = SimpleFieldType | FieldOptions;
-export type FlexibleSchema<T> = Record<keyof T, SchemaValue>;
+export type NormalizedField = FieldOptions;
+export interface ForeignKeyDefinition {
+    column: string;
+    references: {
+        table: string;
+        column: string;
+    };
+    onDelete?: "CASCADE" | "SET NULL" | "RESTRICT";
+    onUpdate?: "CASCADE" | "RESTRICT";
+}
 export declare class Model<T extends Partial<BaseSchema> = BaseSchema> {
     readonly name: string;
-    readonly schema: FlexibleSchema<T>;
     readonly foreignKeys: ForeignKeyDefinition[];
-    constructor(name: string, schema: FlexibleSchema<T>, foreignKeys?: ForeignKeyDefinition[]);
+    readonly indexes: IndexDefinition[];
+    readonly normalizedSchema: Record<keyof T, NormalizedField>;
+    constructor(name: string, schema: Record<keyof T, SchemaValue>, foreignKeys?: ForeignKeyDefinition[], indexes?: IndexDefinition[]);
+    private normalizeSchema;
+    getPrimaryKey(): keyof T | undefined;
 }

package/dist/core/Model.js

@@ -1,11 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
-class Model {
-    constructor(name, schema, foreignKeys = []) {
+/* ---------------------------------- */
+/* Model                               */
+/* ---------------------------------- */
+export class Model {
+    name;
+    foreignKeys;
+    indexes;
+    normalizedSchema;
+    constructor(name, schema, foreignKeys = [], indexes = []) {
         this.name = name;
-        this.schema = schema;
         this.foreignKeys = foreignKeys;
+        this.indexes = indexes;
+        this.normalizedSchema = this.normalizeSchema(schema);
+    }
+    normalizeSchema(schema) {
+        const normalized = {};
+        for (const key of Object.keys(schema)) {
+            const value = schema[key];
+            if (typeof value === "string") {
+                normalized[key] = {
+                    type: value,
+                };
+            }
+            else {
+                normalized[key] = {
+                    required: false,
+                    // @ts-expect-error wierd generic errors
+                    ...value,
+                };
+            }
+        }
+        return normalized;
+    }
+    getPrimaryKey() {
+        for (const key of Object.keys(this.normalizedSchema)) {
+            if (this.normalizedSchema[key].pk)
+                return key;
+        }
+        return undefined;
     }
 }
-exports.Model = Model;

package/dist/core/Repository.d.ts

@@ -1,15 +1,23 @@
-import { Model } from "./Model";
+import { Model } from "./Model.js";
 export declare class Repository<T extends object> {
     readonly model: Model<T>;
     constructor(model: Model<T>);
     create(data: T): Promise<T>;
+    createMany(rows: T[]): Promise<T[]>;
+    bulkInsert(rows: T[]): Promise<number>;
     find(where?: Partial<T>): Promise<T[]>;
     findOne(where: Partial<T>): Promise<T | null>;
-    update(where: Partial<T>, data: Partial<T>): Promise<T | null>;
-    delete(where: Partial<T>): Promise<void>;
     count(where?: Partial<T>): Promise<number>;
     exists(where: Partial<T>): Promise<boolean>;
-    private normalizeValue;
+    findById(id: any): Promise<T | null>;
+    findManyByIds(ids: any[]): Promise<T[]>;
+    update(where: Partial<T>, data: Partial<T>): Promise<T | null>;
+    updateMany(where: Partial<T>, data: Partial<T>): Promise<number>;
+    delete(where: Partial<T>): Promise<void>;
+    deleteMany(where: Partial<T>): Promise<number>;
+    upsert(data: T): Promise<T>;
+    private getInsertableKeys;
+    private normalizeWriteValue;
     private buildWhereClause;
     private getPrimaryKeyField;
 }

package/dist/core/Repository.js

@@ -1,57 +1,115 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
 // Repository.ts
-const Database_1 = require("./Database");
-class Repository {
+import { getPool } from "./Database.js";
+export class Repository {
+    model;
     constructor(model) {
         this.model = model;
-        // Validate PK at construction
         const pk = this.getPrimaryKeyField();
         if (!pk) {
             throw new Error(`Model "${model.name}" has no primary key defined (pk: true)`);
         }
     }
+    /* ---------------------------------- */
+    /* CREATE                              */
+    /* ---------------------------------- */
     async create(data) {
-        const keys = Object.keys(data);
+        const keys = this.getInsertableKeys(data);
         if (keys.length === 0)
             throw new Error("create(): empty data");
-        const sql = `INSERT INTO \`${this.model.name}\` (${keys.map(k => `\`${k}\``).join(",")})
-                     VALUES (${keys.map(() => "?").join(",")})`;
-        const values = keys.map((key) => this.normalizeValue(data[key]));
-        const [res] = await (0, Database_1.getPool)().execute(sql, values);
+        const sql = `
+            INSERT INTO \`${this.model.name}\`
+            (${keys.map(k => `\`${k}\``).join(",")})
+            VALUES (${keys.map(() => "?").join(",")})
+        `;
+        const values = keys.map(k => this.normalizeWriteValue(k, data[k]));
+        const [res] = await getPool().execute(sql, values);
         const pk = this.getPrimaryKeyField();
-        // If PK exists in data, refetch using it
-        if (pk && data[pk] != null) {
-            const row = await this.findOne({ [pk]: data[pk] });
-            if (row)
-                return row;
-        }
-        // If PK is auto-increment and insertId is present
-        if (pk && res.insertId && res.insertId !== 0) {
-            const row = await this.findOne({ [pk]: res.insertId });
-            if (row)
-                return row;
-        }
-        // Fallback — return data + insertId if available
-        if (res.insertId && res.insertId !== 0) {
-            return { ...data, id: res.insertId };
+        if (pk && res.insertId) {
+            return (await this.findById(res.insertId));
         }
         return data;
     }
+    async createMany(rows) {
+        if (rows.length === 0)
+            return [];
+        const keys = this.getInsertableKeys(rows[0]);
+        if (keys.length === 0)
+            throw new Error("createMany(): empty rows");
+        const placeholders = rows
+            .map(() => `(${keys.map(() => "?").join(",")})`)
+            .join(",");
+        const values = rows.flatMap(row => keys.map(k => this.normalizeWriteValue(k, row[k])));
+        const sql = `
+            INSERT INTO \`${this.model.name}\`
+            (${keys.map(k => `\`${k}\``).join(",")})
+            VALUES ${placeholders}
+        `;
+        const [res] = await getPool().execute(sql, values);
+        const pk = this.getPrimaryKeyField();
+        if (!pk || !res.insertId)
+            return rows;
+        const ids = rows.map((_, i) => res.insertId + i);
+        return this.findManyByIds(ids);
+    }
+    async bulkInsert(rows) {
+        if (rows.length === 0)
+            return 0;
+        const keys = this.getInsertableKeys(rows[0]);
+        const placeholders = rows
+            .map(() => `(${keys.map(() => "?").join(",")})`)
+            .join(",");
+        const values = rows.flatMap(row => keys.map(k => this.normalizeWriteValue(k, row[k])));
+        const sql = `
+            INSERT INTO \`${this.model.name}\`
+            (${keys.map(k => `\`${k}\``).join(",")})
+            VALUES ${placeholders}
+        `;
+        const [res] = await getPool().execute(sql, values);
+        return res.affectedRows;
+    }
+    /* ---------------------------------- */
+    /* READ                                */
+    /* ---------------------------------- */
     async find(where = {}) {
         const { sql, params } = this.buildWhereClause(where);
         const query = `SELECT * FROM \`${this.model.name}\` ${sql}`;
-        const [rows] = await (0, Database_1.getPool)().execute(query, params.map(this.normalizeValue));
+        const [rows] = await getPool().execute(query, params);
         return rows;
     }
     async findOne(where) {
         const { sql, params } = this.buildWhereClause(where);
         const query = `SELECT * FROM \`${this.model.name}\` ${sql} LIMIT 1`;
-        const [rows] = await (0, Database_1.getPool)().execute(query, params.map(this.normalizeValue));
-        const results = rows;
-        return results.length > 0 ? results[0] : null;
+        const [rows] = await getPool().execute(query, params);
+        return rows[0] ?? null;
+    }
+    async count(where = {}) {
+        const { sql, params } = this.buildWhereClause(where);
+        const query = `SELECT COUNT(*) as count FROM \`${this.model.name}\` ${sql}`;
+        const [rows] = await getPool().execute(query, params);
+        return rows[0]?.count ?? 0;
+    }
+    async exists(where) {
+        return (await this.count(where)) > 0;
+    }
+    async findById(id) {
+        const pk = this.getPrimaryKeyField();
+        return this.findOne({ [pk]: id });
+    }
+    async findManyByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const pk = this.getPrimaryKeyField();
+        const placeholders = ids.map(() => "?").join(",");
+        const query = `
+            SELECT * FROM \`${this.model.name}\`
+            WHERE \`${String(pk)}\` IN (${placeholders})
+        `;
+        const [rows] = await getPool().execute(query, ids);
+        return rows;
     }
+    /* ---------------------------------- */
+    /* UPDATE                              */
+    /* ---------------------------------- */
     async update(where, data) {
         if (!where || Object.keys(where).length === 0) {
             throw new Error("update(): missing WHERE");
@@ -60,41 +118,103 @@ class Repository {
         if (setKeys.length === 0)
             return this.findOne(where);
         const setClause = setKeys.map(k => `\`${k}\` = ?`).join(", ");
-        const setValues = setKeys.map(k => this.normalizeValue(data[k]));
+        const setValues = setKeys.map(k => this.normalizeWriteValue(k, data[k]));
         const { sql: whereClause, params: whereValues } = this.buildWhereClause(where);
-        const query = `UPDATE \`${this.model.name}\` SET ${setClause} ${whereClause}`;
-        await (0, Database_1.getPool)().execute(query, [...setValues, ...whereValues.map(this.normalizeValue)]);
+        const query = `
+            UPDATE \`${this.model.name}\`
+            SET ${setClause}
+            ${whereClause}
+        `;
+        await getPool().execute(query, [...setValues, ...whereValues]);
         return this.findOne(where);
     }
+    async updateMany(where, data) {
+        if (!where || Object.keys(where).length === 0) {
+            throw new Error("updateMany(): missing WHERE");
+        }
+        const setKeys = Object.keys(data);
+        if (setKeys.length === 0)
+            return 0;
+        const setClause = setKeys.map(k => `\`${k}\` = ?`).join(", ");
+        const setValues = setKeys.map(k => this.normalizeWriteValue(k, data[k]));
+        const { sql, params } = this.buildWhereClause(where);
+        const query = `
+            UPDATE \`${this.model.name}\`
+            SET ${setClause}
+            ${sql}
+        `;
+        const [res] = await getPool().execute(query, [
+            ...setValues,
+            ...params,
+        ]);
+        return res.affectedRows;
+    }
+    /* ---------------------------------- */
+    /* DELETE                              */
+    /* ---------------------------------- */
     async delete(where) {
         const { sql, params } = this.buildWhereClause(where);
         const query = `DELETE FROM \`${this.model.name}\` ${sql}`;
-        await (0, Database_1.getPool)().execute(query, params.map(this.normalizeValue));
+        await getPool().execute(query, params);
     }
-    async count(where = {}) {
+    async deleteMany(where) {
         const { sql, params } = this.buildWhereClause(where);
-        const query = `SELECT COUNT(*) as count FROM \`${this.model.name}\` ${sql}`;
-        const [rows] = await (0, Database_1.getPool)().execute(query, params.map(this.normalizeValue));
-        return rows[0].count || 0;
+        const query = `DELETE FROM \`${this.model.name}\` ${sql}`;
+        const [res] = await getPool().execute(query, params);
+        return res.affectedRows;
     }
-    async exists(where) {
-        const count = await this.count(where);
-        return count > 0;
+    /* ---------------------------------- */
+    /* UPSERT                              */
+    /* ---------------------------------- */
+    async upsert(data) {
+        const pk = this.getPrimaryKeyField();
+        const pkField = this.model.normalizedSchema[pk];
+        if (pkField?.autoIncrement) {
+            throw new Error("upsert() does not support auto-increment primary keys");
+        }
+        const keys = this.getInsertableKeys(data);
+        const insertCols = keys.map(k => `\`${k}\``).join(",");
+        const insertVals = keys.map(() => "?").join(",");
+        const updateCols = keys
+            .filter(k => k !== pk)
+            .map(k => `\`${k}\` = VALUES(\`${k}\`)`)
+            .join(",");
+        const values = keys.map(k => this.normalizeWriteValue(k, data[k]));
+        const sql = `
+            INSERT INTO \`${this.model.name}\`
+            (${insertCols})
+            VALUES (${insertVals})
+            ON DUPLICATE KEY UPDATE ${updateCols}
+        `;
+        await getPool().execute(sql, values);
+        return (await this.findOne({ [pk]: data[pk] }));
     }
-    normalizeValue(value) {
-        if (value instanceof Date) {
+    /* ---------------------------------- */
+    /* INTERNAL HELPERS                    */
+    /* ---------------------------------- */
+    getInsertableKeys(data) {
+        return Object.keys(data).filter(key => {
+            const field = this.model.normalizedSchema[key];
+            return !(field?.pk && field?.autoIncrement);
+        });
+    }
+    normalizeWriteValue(key, value) {
+        const field = this.model.normalizedSchema[key];
+        if (value == null)
+            return null;
+        if (field?.type === "datetime" && value instanceof Date) {
             return value.toISOString().slice(0, 19).replace("T", " ");
         }
-        if (typeof value === "object" && value !== null) {
+        if (field?.type === "json") {
             return JSON.stringify(value);
         }
-        return value ?? null;
+        return value;
     }
     buildWhereClause(where) {
         const keys = Object.keys(where);
         if (keys.length === 0)
             return { sql: "", params: [] };
-        const conditions = keys.map(k => `${k} = ?`).join(" AND ");
+        const conditions = keys.map(k => `\`${k}\` = ?`).join(" AND ");
         const values = keys.map(k => where[k]);
         return {
             sql: `WHERE ${conditions}`,
@@ -102,12 +222,6 @@ class Repository {
         };
     }
     getPrimaryKeyField() {
-        for (const key of Object.keys(this.model.schema)) {
-            if (this.model.schema[key]?.pk) {
-                return key;
-            }
-        }
-        return undefined;
+        return this.model.getPrimaryKey();
     }
 }
-exports.Repository = Repository;

package/dist/core/index.d.ts

@@ -1,3 +1,4 @@
-export * from './Model';
-export * from './Repository';
-export * from './Database';
+export * from './Model.js';
+export * from './Repository.js';
+export * from './Database.js';
+export * from './Migration.js';

package/dist/core/index.js

@@ -1,19 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Model"), exports);
-__exportStar(require("./Repository"), exports);
-__exportStar(require("./Database"), exports);
+export * from './Model.js';
+export * from './Repository.js';
+export * from './Database.js';
+export * from './Migration.js';

package/dist/index.d.ts

@@ -1,2 +1,8 @@
-export * from './core';
-export * from './utils';
+export * from "./core/Database.js";
+export * from "./core/Model.js";
+export * from "./core/Repository.js";
+export * from "./core/Migration.js";
+export * from './utils/getNextId.js';
+export * from './utils/syncSchema.js';
+export * from './utils/types.js';
+export * from './utils/genNewUUID.js';

package/dist/index.js

@@ -1,18 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core"), exports);
-__exportStar(require("./utils"), exports);
+export * from "./core/Database.js";
+export * from "./core/Model.js";
+export * from "./core/Repository.js";
+export * from "./core/Migration.js";
+export * from './utils/getNextId.js';
+export * from './utils/syncSchema.js';
+export * from './utils/types.js';
+export * from './utils/genNewUUID.js';

package/dist/utils/genNewUUID.d.ts

@@ -0,0 +1 @@
+export declare function genNewUUID(): string;

package/dist/utils/genNewUUID.js

@@ -0,0 +1,4 @@
+import { randomUUID } from "crypto";
+export function genNewUUID() {
+    return randomUUID();
+}

package/dist/utils/getNextId.js

@@ -1,23 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNextId = getNextId;
-const core_1 = require("../core");
-async function getNextId(prefix) {
-    const pool = (0, core_1.getPool)();
+import { getPool } from "../core/Database.js";
+export async function getNextId(prefix) {
+    const pool = getPool();
+    // Ensure table exists (safe to call multiple times)
     await pool.execute(`
-    CREATE TABLE IF NOT EXISTS _id_counters (
-      prefix VARCHAR(255) PRIMARY KEY,
-      count INT NOT NULL
-    )
-  `);
+        CREATE TABLE IF NOT EXISTS _id_counters (
+                                                    prefix VARCHAR(255) PRIMARY KEY,
+            count INT NOT NULL
+            )
+    `);
+    // Atomic upsert + increment
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [result] = await pool.execute(`
+            INSERT INTO _id_counters (prefix, count)
+            VALUES (?, 1)
+                ON DUPLICATE KEY UPDATE count = count + 1
+        `, [prefix]);
+    // Fetch the new value
     const [rows] = await pool.query(`SELECT count FROM _id_counters WHERE prefix = ?`, [prefix]);
-    let count = 1;
-    if (rows.length > 0) {
-        count = rows[0].count + 1;
-        await pool.execute(`UPDATE _id_counters SET count = ? WHERE prefix = ?`, [count, prefix]);
-    }
-    else {
-        await pool.execute(`INSERT INTO _id_counters (prefix, count) VALUES (?, ?)`, [prefix, count]);
-    }
+    const count = rows[0].count;
     return `${prefix}-${String(count).padStart(3, "0")}`;
 }

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
-export * from './getNextId';
-export * from './syncSchema';
-export * from './types';
+export * from './getNextId.js';
+export * from './syncSchema.js';
+export * from './types.js';
+export * from './genNewUUID.js';

package/dist/utils/index.js

@@ -1,19 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./getNextId"), exports);
-__exportStar(require("./syncSchema"), exports);
-__exportStar(require("./types"), exports);
+export * from './getNextId.js';
+export * from './syncSchema.js';
+export * from './types.js';
+export * from './genNewUUID.js';

package/dist/utils/syncSchema.d.ts

@@ -1 +1,5 @@
-export declare function syncSchema(): Promise<void>;
+export declare function syncSchema(options?: {
+    generate?: boolean;
+    apply?: boolean;
+    migrationsPath?: string;
+}): Promise<void>;

package/dist/utils/syncSchema.js

@@ -1,51 +1,133 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncSchema = syncSchema;
-const core_1 = require("../core");
-function normalizeField(value) {
-    if (typeof value === "string")
-        return { type: value };
-    return value;
+// syncSchema.ts
+import fs from "fs";
+import path from "path";
+import { getAllModels, getPool } from "../core/Database.js";
+/* ---------------------------------- */
+/* Helpers                            */
+/* ---------------------------------- */
+function mapType(type) {
+    switch (type) {
+        case "string": return "VARCHAR(255)";
+        case "json": return "JSON";
+        case "datetime": return "DATETIME";
+        case "int": return "INT";
+        case "float": return "FLOAT";
+        case "boolean": return "BOOLEAN";
+        default: return type;
+    }
 }
 function formatDefault(value) {
     if (typeof value === "string")
         return `'${value}'`;
     if (typeof value === "boolean")
         return value ? "TRUE" : "FALSE";
-    if (value === null || value === undefined)
+    if (value == null)
         return "NULL";
     return value.toString();
 }
-function mapType(type) {
-    switch (type.toLowerCase()) {
-        case "string": return "VARCHAR(255)";
-        case "json": return "JSON";
-        case "datetime": return "DATETIME";
-        case "number": return "INT";
-        case "float": return "FLOAT";
-        case "boolean": return "BOOLEAN";
-        default: return type;
-    }
+/* ---------------------------------- */
+/* DB Introspection                   */
+/* ---------------------------------- */
+async function getExistingTables() {
+    const pool = getPool();
+    const [rows] = await pool.query("SHOW TABLES");
+    // @ts-expect-error wierd generic errors
+    return new Set(Object.values(rows[0] ?? {}).length ? rows.map(r => Object.values(r)[0]) : []);
 }
-async function syncSchema() {
-    const models = (0, core_1.getAllModels)();
-    const pool = (0, core_1.getPool)();
-    for (const [name, model] of models.entries()) {
-        const columns = [];
-        for (const [key, value] of Object.entries(model.schema)) {
-            const { type, pk, default: def, required } = normalizeField(value);
-            let col = `\`${key}\` ${mapType(type)}`;
-            if (required || pk)
-                col += " NOT NULL";
-            if (pk)
-                col += " PRIMARY KEY";
-            if (def !== undefined)
-                col += ` DEFAULT ${formatDefault(def)}`;
-            columns.push(col);
+/* ---------------------------------- */
+/* Migration Generator                */
+/* ---------------------------------- */
+export async function syncSchema(options) {
+    const generate = options?.generate ?? true;
+    const apply = options?.apply ?? false;
+    const migrationsPath = options?.migrationsPath ?? "./migrations";
+    if (process.env.NODE_ENV === "production" && apply) {
+        throw new Error("syncSchema(): cannot apply schema changes in production");
+    }
+    const models = getAllModels();
+    const pool = getPool();
+    const existingTables = await getExistingTables();
+    const statements = [];
+    for (const [tableName, model] of models.entries()) {
+        if (existingTables.has(tableName))
+            continue;
+        statements.push(generateCreateTableSQL(model));
+        statements.push(...generateIndexSQL(model));
+    }
+    if (statements.length === 0) {
+        console.log("✅ Schema already in sync.");
+        return;
+    }
+    if (generate) {
+        emitMigration(statements, migrationsPath);
+    }
+    if (apply) {
+        for (const sql of statements) {
+            await pool.execute(sql);
         }
-        const fks = model.foreignKeys.map(fk => `FOREIGN KEY (\`${fk.column}\`) REFERENCES ${fk.reference}`);
-        const sql = `CREATE TABLE IF NOT EXISTS \`${name}\` (\n  ${[...columns, ...fks].join(',\n  ')}\n);`;
-        await pool.execute(sql);
+        console.log("✅ Schema applied (dev mode).");
+    }
+}
+/* ---------------------------------- */
+/* SQL Builders                       */
+/* ---------------------------------- */
+function generateCreateTableSQL(model) {
+    const columns = [];
+    for (const [key, field] of Object.entries(model.normalizedSchema)) {
+        let col = `\`${key}\` ${mapType(field.type)}`;
+        if (field.pk)
+            col += " PRIMARY KEY";
+        if (field.autoIncrement)
+            col += " AUTO_INCREMENT";
+        if (field.required || field.pk)
+            col += " NOT NULL";
+        if (field.default !== undefined)
+            col += ` DEFAULT ${formatDefault(field.default)}`;
+        columns.push(col);
+    }
+    const fks = model.foreignKeys.map(fk => `FOREIGN KEY (\`${fk.column}\`) REFERENCES \`${fk.references.table}\`(\`${fk.references.column}\`)`);
+    return `
+CREATE TABLE \`${model.name}\` (
+  ${[...columns, ...fks].join(",\n  ")}
+);`.trim();
+}
+function generateIndexSQL(model) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return model.indexes.map((idx, i) => {
+        const name = idx.name ??
+            `idx_${model.name}_${idx.columns.join("_")}`;
+        const unique = idx.unique ? "UNIQUE " : "";
+        const cols = idx.columns.map(c => `\`${c}\``).join(", ");
+        return `CREATE ${unique}INDEX \`${name}\` ON \`${model.name}\` (${cols});`;
+    });
+}
+/* ---------------------------------- */
+/* Migration Writer                   */
+/* ---------------------------------- */
+function emitMigration(sql, dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
     }
-    console.log("✅ Schema synchronized.");
+    const id = new Date()
+        .toISOString()
+        .replace(/[-:T.Z]/g, "")
+        .slice(0, 14);
+    const filename = `${id}_auto_sync.ts`;
+    const filePath = path.join(dir, filename);
+    const content = `
+import type { Migration } from "@shadow-dev/orm";
+
+export const migration: Migration = {
+  id: "${id}",
+  name: "auto_sync",
+
+  async up(db) {
+${sql
+        .map(s => `    await db.exec(\`${s.replace(/`/g, "\\`")}\`);`)
+        .join("\n")}
+  }
+};
+`.trim();
+    fs.writeFileSync(filePath, content, { encoding: "utf8" });
+    console.log(`📝 Migration generated: ${filePath}`);
 }

package/dist/utils/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@shadow-dev/orm",
-  "version": "1.0.3",
+  "version": "2.0.0",
   "description": "Lightweight dynamic MySQL ORM designed for ShadowCore and modular apps.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": ["dist"],
+  "type": "module",
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },