@bunnykit/orm 0.1.2 → 0.1.4

package/dist/src/model/Model.d.ts

@@ -82,6 +82,9 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static timestamps: boolean;
     static connection?: Connection;
     static dateFormat: string;
+    static keyType: "int" | "string" | "uuid";
+    static incrementing: boolean;
+    static usesUuids: boolean;
     static morphName?: string;
     static casts: Record<string, CastDefinition>;
     static fillable: string[];
@@ -103,6 +106,7 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static removeGlobalScope(name: string): void;
     static applyGlobalScopes(builder: Builder<any>): void;
     static getQualifiedDeletedAtColumn(): string;
+    static shouldAutoGeneratePrimaryKey(): Promise<boolean>;
     static create<M extends typeof Model>(this: M, attributes: Partial<InstanceType<M> extends Model<infer U> ? U : Record<string, any>>): Promise<InstanceType<M>>;
     static find<M extends typeof Model>(this: M, id: any): Promise<InstanceType<M> | null>;
     static first<M extends typeof Model>(this: M): Promise<InstanceType<M> | null>;

package/dist/src/model/Model.js

@@ -3,6 +3,7 @@ import { snakeCase } from "../utils.js";
 import { ObserverRegistry } from "./Observer.js";
 import { MorphTo, MorphOne, MorphMany, MorphToMany } from "./MorphRelations.js";
 import { BelongsToMany } from "./BelongsToMany.js";
+import { Schema } from "../schema/Schema.js";
 const globalScopes = new WeakMap();
 function getGlobalScopes(model) {
     const scopes = new Map();
@@ -276,6 +277,9 @@ export class Model {
     static timestamps = true;
     static connection;
     static dateFormat = "YYYY-MM-DD HH:mm:ss";
+    static keyType = "int";
+    static incrementing = true;
+    static usesUuids = false;
     static morphName;
     static casts = {};
     static fillable = [];
@@ -370,6 +374,20 @@ export class Model {
     static getQualifiedDeletedAtColumn() {
         return `${this.getTable()}.${this.deletedAtColumn}`;
     }
+    static async shouldAutoGeneratePrimaryKey() {
+        if (this.usesUuids || this.keyType === "uuid")
+            return true;
+        const column = await Schema.getColumn(this.getTable(), this.primaryKey);
+        if (!column)
+            return false;
+        if (!column.primary)
+            return false;
+        if (column.autoIncrement)
+            return false;
+        const type = String(column.type || "").toLowerCase();
+        const numericTypes = new Set(["integer", "int", "bigint", "smallint", "tinyint", "real", "float", "double", "decimal", "numeric"]);
+        return !numericTypes.has(type);
+    }
     static async create(attributes) {
         const instance = new this();
         instance.fill(attributes);
@@ -632,9 +650,21 @@ export class Model {
                 this.$attributes["created_at"] = now;
                 this.$attributes["updated_at"] = now;
             }
-            const result = await new Builder(constructor.getConnection(), constructor.getTable()).insertGetId(this.$attributes);
-            if (result) {
-                this.$attributes[constructor.primaryKey] = result;
+            const primaryKey = constructor.primaryKey;
+            const primaryKeyValue = this.getAttribute(primaryKey);
+            const shouldGeneratePrimaryKey = await constructor.shouldAutoGeneratePrimaryKey();
+            if ((primaryKeyValue === null || primaryKeyValue === undefined || primaryKeyValue === "") && shouldGeneratePrimaryKey) {
+                const generated = crypto.randomUUID();
+                this.$attributes[primaryKey] = generated;
+            }
+            if (shouldGeneratePrimaryKey || primaryKeyValue !== null && primaryKeyValue !== undefined && primaryKeyValue !== "") {
+                await new Builder(constructor.getConnection(), constructor.getTable()).insert(this.$attributes);
+            }
+            else {
+                const result = await new Builder(constructor.getConnection(), constructor.getTable()).insertGetId(this.$attributes);
+                if (result) {
+                    this.$attributes[constructor.primaryKey] = result;
+                }
             }
             this.$exists = true;
             this.$original = { ...this.$attributes };

package/dist/src/schema/Schema.d.ts

@@ -13,4 +13,10 @@ export declare class Schema {
     static rename(from: string, to: string): Promise<void>;
     static hasTable(table: string): Promise<boolean>;
     static hasColumn(table: string, column: string): Promise<boolean>;
+    static getColumn(table: string, column: string): Promise<{
+        name: string;
+        type: string;
+        primary: boolean;
+        autoIncrement: boolean;
+    } | null>;
 }

package/dist/src/schema/Schema.js

@@ -132,4 +132,31 @@ export class Schema {
         const result = await this.getConnection().query(sql);
         return result.length > 0;
     }
+    static async getColumn(table, column) {
+        const driver = this.getConnection().getDriverName();
+        if (driver === "sqlite") {
+            const rows = await this.getConnection().query(`PRAGMA table_info(${table})`);
+            const row = rows.find((item) => item.name === column);
+            return row ? { name: row.name, type: row.type, primary: row.pk > 0, autoIncrement: false } : null;
+        }
+        if (driver === "mysql") {
+            const rows = await this.getConnection().query(`SHOW COLUMNS FROM ${table} LIKE '${column}'`);
+            const row = rows[0];
+            return row ? { name: row.Field, type: row.Type, primary: row.Key === "PRI", autoIncrement: String(row.Extra || "").toLowerCase().includes("auto_increment") } : null;
+        }
+        const rows = await this.getConnection().query(`SELECT c.column_name, c.data_type, COALESCE(tc.constraint_type = 'PRIMARY KEY', false) AS primary_key
+       FROM information_schema.columns c
+       LEFT JOIN information_schema.key_column_usage kcu
+         ON c.table_schema = kcu.table_schema
+        AND c.table_name = kcu.table_name
+        AND c.column_name = kcu.column_name
+       LEFT JOIN information_schema.table_constraints tc
+         ON kcu.table_schema = tc.table_schema
+        AND kcu.constraint_name = tc.constraint_name
+       WHERE c.table_schema = 'public'
+         AND c.table_name = '${table}'
+         AND c.column_name = '${column}'`);
+        const row = rows[0];
+        return row ? { name: row.column_name, type: row.data_type, primary: !!row.primary_key, autoIncrement: false } : null;
+    }
 }

package/dist/src/schema/grammars/SQLiteGrammar.js

@@ -48,6 +48,8 @@ export class SQLiteGrammar extends Grammar {
         let sql = `${this.wrap(column.name)} ${this.getType(column)}`;
         if (column.autoIncrement)
             sql += this.modifyAutoIncrement(column);
+        else if (column.primary)
+            sql += " PRIMARY KEY";
         if (!column.nullable)
             sql += " NOT NULL";
         if (column.default !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",