@shadow-dev/orm 1.0.1 → 1.0.3

package/dist/core/Model.d.ts

@@ -1,15 +1,24 @@
 export interface BaseSchema {
-    id: string;
+    id?: string;
     data?: any;
-    createdAt: Date;
+    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;
+    required?: boolean;
+    default?: any;
+}
+export type SchemaValue = SimpleFieldType | FieldOptions;
+export type FlexibleSchema<T> = Record<keyof T, SchemaValue>;
 export declare class Model<T extends Partial<BaseSchema> = BaseSchema> {
     readonly name: string;
-    readonly schema: Record<keyof T, string>;
+    readonly schema: FlexibleSchema<T>;
     readonly foreignKeys: ForeignKeyDefinition[];
-    constructor(name: string, schema: Record<keyof T, string>, foreignKeys?: ForeignKeyDefinition[]);
+    constructor(name: string, schema: FlexibleSchema<T>, foreignKeys?: ForeignKeyDefinition[]);
 }

package/dist/core/Repository.d.ts

@@ -2,13 +2,14 @@ import { Model } from "./Model";
 export declare class Repository<T extends object> {
     readonly model: Model<T>;
     constructor(model: Model<T>);
-    create(data: T): Promise<void>;
+    create(data: T): Promise<T>;
     find(where?: Partial<T>): Promise<T[]>;
     findOne(where: Partial<T>): Promise<T | null>;
-    update(where: Partial<T>, data: Partial<T>): Promise<void>;
+    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;
     private buildWhereClause;
+    private getPrimaryKeyField;
 }

package/dist/core/Repository.js

@@ -6,12 +6,38 @@ const Database_1 = require("./Database");
 class Repository {
     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)`);
+        }
     }
     async create(data) {
         const keys = Object.keys(data);
-        const sql = `INSERT INTO \`${this.model.name}\` (${keys.join(",")}) VALUES (${keys.map(() => "?").join(",")})`;
+        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]));
-        await (0, Database_1.getPool)().execute(sql, values);
+        const [res] = await (0, Database_1.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 };
+        }
+        return data;
     }
     async find(where = {}) {
         const { sql, params } = this.buildWhereClause(where);
@@ -27,12 +53,18 @@ class Repository {
         return results.length > 0 ? results[0] : null;
     }
     async update(where, data) {
+        if (!where || Object.keys(where).length === 0) {
+            throw new Error("update(): missing WHERE");
+        }
         const setKeys = Object.keys(data);
-        const setClause = setKeys.map(k => `${k} = ?`).join(", ");
+        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 { 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)]);
+        return this.findOne(where);
     }
     async delete(where) {
         const { sql, params } = this.buildWhereClause(where);
@@ -69,5 +101,13 @@ class Repository {
             params: values,
         };
     }
+    getPrimaryKeyField() {
+        for (const key of Object.keys(this.model.schema)) {
+            if (this.model.schema[key]?.pk) {
+                return key;
+            }
+        }
+        return undefined;
+    }
 }
 exports.Repository = Repository;

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./getNextId"), exports);
 __exportStar(require("./syncSchema"), exports);
+__exportStar(require("./types"), exports);

package/dist/utils/syncSchema.js

@@ -2,23 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncSchema = syncSchema;
 const core_1 = require("../core");
-async function syncSchema() {
-    const models = (0, core_1.getAllModels)();
-    const pool = (0, core_1.getPool)();
-    for (const [name, model] of models.entries()) {
-        const columns = [];
-        const foreignKeys = [];
-        for (const [key, type] of Object.entries(model.schema)) {
-            columns.push(`\`${key}\` ${mapType(type)}`);
-        }
-        for (const fk of model.foreignKeys) {
-            foreignKeys.push(`FOREIGN KEY (\`${fk.column}\`) REFERENCES ${fk.reference}`);
-        }
-        const columnDefs = [...columns, ...foreignKeys].join(",\n  ");
-        const sql = `CREATE TABLE IF NOT EXISTS \`${name}\` (\n  ${columnDefs}\n);`;
-        await pool.execute(sql);
-    }
-    console.log("✅ Schema synchronized.");
+function normalizeField(value) {
+    if (typeof value === "string")
+        return { type: value };
+    return value;
+}
+function formatDefault(value) {
+    if (typeof value === "string")
+        return `'${value}'`;
+    if (typeof value === "boolean")
+        return value ? "TRUE" : "FALSE";
+    if (value === null || value === undefined)
+        return "NULL";
+    return value.toString();
 }
 function mapType(type) {
     switch (type.toLowerCase()) {
@@ -26,7 +22,30 @@ function mapType(type) {
         case "json": return "JSON";
         case "datetime": return "DATETIME";
         case "number": return "INT";
+        case "float": return "FLOAT";
         case "boolean": return "BOOLEAN";
-        default: return type; // fallback for raw SQL types if provided
+        default: return type;
+    }
+}
+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);
+        }
+        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 synchronized.");
 }

package/dist/utils/types.d.ts

@@ -0,0 +1,3 @@
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};

package/dist/utils/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shadow-dev/orm",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Lightweight dynamic MySQL ORM designed for ShadowCore and modular apps.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",