canxjs 1.2.2 → 1.2.3

package/dist/index.js

@@ -27164,6 +27164,7 @@ class TestResponse {
 // src/mvc/Model.ts
 var mysqlPool = null;
 var pgPool = null;
+var sqliteDb = null;
 var currentDriver = "mysql";
 var dbConfig = null;
 async function initDatabase(config) {
@@ -27194,6 +27195,10 @@ async function initDatabase(config) {
       idleTimeoutMillis: config.pool?.idle || 30000
     });
     console.log("[CanxJS] PostgreSQL connection pool created");
+  } else if (config.driver === "sqlite") {
+    const { Database } = await import("bun:sqlite");
+    sqliteDb = new Database(config.database);
+    console.log("[CanxJS] SQLite database connected");
   }
 }
 async function closeDatabase() {
@@ -27205,6 +27210,13 @@ async function closeDatabase() {
     await pgPool.end();
     pgPool = null;
   }
+  if (sqliteDb) {
+    sqliteDb.close();
+    sqliteDb = null;
+  }
+}
+function getCurrentDriver() {
+  return currentDriver;
 }
 async function query(sql, params = []) {
   if (dbConfig?.logging)
@@ -27217,6 +27229,9 @@ async function query(sql, params = []) {
     const pgSql = sql.replace(/\?/g, () => `$${++idx}`);
     const result = await pgPool.query(pgSql, params);
     return result.rows;
+  } else if (currentDriver === "sqlite" && sqliteDb) {
+    const query2 = sqliteDb.query(sql);
+    return query2.all(...params);
   }
   throw new Error("No database connection");
 }
@@ -27231,6 +27246,10 @@ async function execute(sql, params = []) {
     const pgSql = sql.replace(/\?/g, () => `$${++idx}`);
     const result = await pgPool.query(pgSql + " RETURNING *", params);
     return { affectedRows: result.rowCount || 0, insertId: result.rows[0]?.id || 0 };
+  } else if (currentDriver === "sqlite" && sqliteDb) {
+    const query2 = sqliteDb.query(sql);
+    const result = query2.run(...params);
+    return { affectedRows: result.changes, insertId: result.lastInsertRowid };
   }
   throw new Error("No database connection");
 }
@@ -27246,8 +27265,12 @@ class QueryBuilderImpl {
   groupClauses = [];
   havingClauses = [];
   bindings = [];
-  constructor(table) {
+  modelClass;
+  withRelations = [];
+  _relationInfo;
+  constructor(table, modelClass) {
     this.table = table;
+    this.modelClass = modelClass;
   }
   select(...cols) {
     this.selectCols = cols.length ? cols : ["*"];
@@ -27259,6 +27282,10 @@ class QueryBuilderImpl {
     return this;
   }
   whereIn(col, vals) {
+    if (vals.length === 0) {
+      this.whereClauses.push("1 = 0");
+      return this;
+    }
     this.whereClauses.push(`${String(col)} IN (${vals.map(() => "?").join(",")})`);
     this.bindings.push(...vals);
     return this;
@@ -27310,6 +27337,10 @@ class QueryBuilderImpl {
     this.bindings.push(val);
     return this;
   }
+  with(...relations) {
+    this.withRelations.push(...relations);
+    return this;
+  }
   buildSelect() {
     let sql = `SELECT ${this.selectCols.join(", ")} FROM ${this.table}`;
     if (this.joinClauses.length)
@@ -27329,26 +27360,105 @@ class QueryBuilderImpl {
     return sql;
   }
   async get() {
-    return query(this.buildSelect(), this.bindings);
+    const rows = await query(this.buildSelect(), this.bindings);
+    let results = rows;
+    if (this.modelClass) {
+      results = rows.map((r) => new this.modelClass().fill(r));
+    }
+    if (this.withRelations.length > 0 && this.modelClass && results.length > 0) {
+      await this.eagerLoad(results);
+    }
+    return results;
+  }
+  async eagerLoad(results) {
+    const instance = new this.modelClass;
+    for (const relationName of this.withRelations) {
+      if (typeof instance[relationName] !== "function") {
+        console.warn(`[Model] Relation method '${relationName}' not found on ${this.modelClass.name}`);
+        continue;
+      }
+      const relationQuery = instance[relationName]();
+      const info = relationQuery._relationInfo;
+      if (!info) {
+        console.warn(`[Model] Method '${relationName}' did not return a valid relation QueryBuilder`);
+        continue;
+      }
+      if (info.type === "hasMany" || info.type === "hasOne") {
+        const localKey = info.localKey || "id";
+        const foreignKey = info.foreignKey;
+        const parentIds = results.map((r) => r[localKey]).filter((id) => id !== undefined && id !== null);
+        if (parentIds.length === 0)
+          continue;
+        const uniqueIds = [...new Set(parentIds)];
+        const relatedResults = await info.relatedClass.query().whereIn(foreignKey, uniqueIds).get();
+        for (const parent of results) {
+          const parentId = parent[localKey];
+          if (info.type === "hasMany") {
+            parent.startRelation(relationName);
+            parent.relations[relationName] = relatedResults.filter((r) => r[foreignKey] == parentId);
+          } else {
+            parent.startRelation(relationName);
+            parent.relations[relationName] = relatedResults.find((r) => r[foreignKey] == parentId) || null;
+          }
+        }
+      } else if (info.type === "belongsTo") {
+        const foreignKey = info.foreignKey;
+        const ownerKey = info.ownerKey || "id";
+        const relatedIds = results.map((r) => r[foreignKey]).filter((id) => id !== undefined && id !== null);
+        if (relatedIds.length === 0)
+          continue;
+        const uniqueIds = [...new Set(relatedIds)];
+        const relatedResults = await info.relatedClass.query().whereIn(ownerKey, uniqueIds).get();
+        for (const parent of results) {
+          const relatedId = parent[foreignKey];
+          parent.startRelation(relationName);
+          parent.relations[relationName] = relatedResults.find((r) => r[ownerKey] == relatedId) || null;
+        }
+      } else if (info.type === "belongsToMany") {
+        const localKey = "id";
+        const parentIds = results.map((r) => r[localKey]).filter((id) => id !== undefined && id !== null);
+        if (parentIds.length === 0)
+          continue;
+        const uniqueIds = [...new Set(parentIds)];
+        const pivotSql = `SELECT * FROM ${info.pivotTable} WHERE ${info.foreignPivotKey} IN (${uniqueIds.map(() => "?").join(",")})`;
+        const pivotRows = await query(pivotSql, uniqueIds);
+        if (pivotRows.length === 0) {
+          for (const parent of results) {
+            parent.startRelation(relationName);
+            parent.relations[relationName] = [];
+          }
+          continue;
+        }
+        const relatedIds = pivotRows.map((r) => r[info.relatedPivotKey]);
+        const uniqueRelatedIds = [...new Set(relatedIds)];
+        const relatedResults = await info.relatedClass.query().whereIn("id", uniqueRelatedIds).get();
+        for (const parent of results) {
+          parent.startRelation(relationName);
+          const myPivotRows = pivotRows.filter((r) => r[info.foreignPivotKey] == parent[localKey]);
+          const myRelatedIds = myPivotRows.map((r) => r[info.relatedPivotKey]);
+          parent.relations[relationName] = relatedResults.filter((r) => myRelatedIds.includes(r.id));
+        }
+      }
+    }
   }
   async first() {
     this.limitVal = 1;
-    const r = await this.get();
-    return r[0] || null;
+    const rows = await this.get();
+    return rows[0] || null;
   }
   async count() {
     this.selectCols = ["COUNT(*) as count"];
-    const r = await this.get();
+    const r = await query(this.buildSelect(), this.bindings);
     return r[0]?.count || 0;
   }
   async sum(col) {
     this.selectCols = [`SUM(${String(col)}) as sum`];
-    const r = await this.get();
+    const r = await query(this.buildSelect(), this.bindings);
     return r[0]?.sum || 0;
   }
   async avg(col) {
     this.selectCols = [`AVG(${String(col)}) as avg`];
-    const r = await this.get();
+    const r = await query(this.buildSelect(), this.bindings);
     return r[0]?.avg || 0;
   }
   async insert(data) {
@@ -27358,6 +27468,9 @@ class QueryBuilderImpl {
     const placeholders = values.map(() => `(${keys.map(() => "?").join(",")})`).join(",");
     const sql = `INSERT INTO ${this.table} (${keys.join(",")}) VALUES ${placeholders}`;
     const result = await execute(sql, values.flat());
+    if (this.modelClass) {
+      return new this.modelClass().fill({ ...items[0], id: result.insertId });
+    }
     return { ...items[0], id: result.insertId };
   }
   async update(data) {
@@ -27386,14 +27499,39 @@ class Model {
   static tableName;
   static primaryKey = "id";
   static timestamps = true;
+  relations = {};
+  constructor(data) {
+    if (data)
+      Object.assign(this, data);
+  }
   static table() {
-    return new QueryBuilderImpl(this.tableName);
+    return new QueryBuilderImpl(this.tableName, this);
   }
   static async find(id) {
-    return new QueryBuilderImpl(this.tableName).where(this.primaryKey, "=", id).first();
+    return this.table().where(this.primaryKey, "=", id).first();
+  }
+  static query() {
+    return new QueryBuilderImpl(this.tableName, this);
   }
   static async all() {
-    return new QueryBuilderImpl(this.tableName).get();
+    return this.query().get();
+  }
+  startRelation(name) {
+    if (!this.relations)
+      this.relations = {};
+  }
+  async load(...relations) {
+    const builder = new QueryBuilderImpl(this.constructor.tableName, this.constructor);
+    builder.with(...relations);
+    await builder.eagerLoad([this]);
+    return this;
+  }
+  static with(...relations) {
+    return this.query().with(...relations);
+  }
+  fill(data) {
+    Object.assign(this, data);
+    return this;
   }
   static async create(data) {
     if (this.timestamps) {
@@ -27401,7 +27539,7 @@ class Model {
       data.created_at = now;
       data.updated_at = now;
     }
-    return new QueryBuilderImpl(this.tableName).insert(data);
+    return this.query().insert(data);
   }
   static async updateById(id, data) {
     if (this.timestamps) {
@@ -27412,8 +27550,49 @@ class Model {
   static async deleteById(id) {
     return new QueryBuilderImpl(this.tableName).where(this.primaryKey, "=", id).delete();
   }
-  static query() {
-    return new QueryBuilderImpl(this.tableName);
+  hasOne(related, foreignKey, localKey = "id") {
+    const fk = foreignKey || `${this.constructor.name.toLowerCase()}_id`;
+    const pk = this[localKey];
+    const qb = related.query();
+    const info = { type: "hasOne", relatedClass: related, foreignKey: fk, localKey };
+    qb._relationInfo = info;
+    const promise = qb.where(fk, "=", pk).first();
+    promise._relationInfo = info;
+    return promise;
+  }
+  hasMany(related, foreignKey, localKey = "id") {
+    const fk = foreignKey || `${this.constructor.name.toLowerCase()}_id`;
+    const pk = this[localKey];
+    const qb = related.query().where(fk, "=", pk);
+    const info = { type: "hasMany", relatedClass: related, foreignKey: fk, localKey };
+    qb._relationInfo = info;
+    return qb;
+  }
+  belongsTo(related, foreignKey, ownerKey = "id") {
+    const fk = foreignKey || `${related.name.toLowerCase()}_id`;
+    const val = this[fk];
+    const qb = related.query();
+    const info = { type: "belongsTo", relatedClass: related, foreignKey: fk, ownerKey };
+    qb._relationInfo = info;
+    const promise = qb.where(ownerKey, "=", val).first();
+    promise._relationInfo = info;
+    return promise;
+  }
+  belongsToMany(related, pivotTable, foreignPivotKey, relatedPivotKey) {
+    const foreignKey = foreignPivotKey || `${this.constructor.name.toLowerCase()}_id`;
+    const relatedKey = relatedPivotKey || `${related.name.toLowerCase()}_id`;
+    const pk = this.id;
+    const qb = related.query();
+    const info = {
+      type: "belongsToMany",
+      relatedClass: related,
+      foreignKey: "",
+      pivotTable,
+      foreignPivotKey: foreignKey,
+      relatedPivotKey: relatedKey
+    };
+    qb._relationInfo = info;
+    return qb.select(`${related.tableName}.*`).join(pivotTable, `${pivotTable}.${relatedKey}`, "=", `${related.tableName}.id`).where(`${pivotTable}.${foreignKey}`, "=", pk);
   }
 }
 // src/mvc/View.ts
@@ -27987,6 +28166,66 @@ var jitCompiler = new JITCompiler;
 function createJITCompiler() {
   return new JITCompiler;
 }
+// src/auth/drivers/DatabaseSessionDriver.ts
+class SessionModel extends Model {
+  static tableName = "sessions";
+  static primaryKey = "id";
+  static timestamps = false;
+}
+
+class DatabaseSessionDriver {
+  generateId() {
+    return `sess_${Date.now().toString(36)}_${crypto.randomUUID().replace(/-/g, "")}`;
+  }
+  async create(userId, data, maxAge) {
+    const id = this.generateId();
+    const expiresAt = Date.now() + maxAge;
+    const payload = JSON.stringify(data);
+    await SessionModel.create({
+      id,
+      user_id: userId,
+      payload,
+      last_activity: new Date(Date.now()).toISOString().slice(0, 19).replace("T", " "),
+      expires_at: expiresAt
+    });
+    return {
+      id,
+      userId,
+      data,
+      expiresAt
+    };
+  }
+  async get(id) {
+    const record = await SessionModel.find(id);
+    if (!record)
+      return null;
+    const now = Date.now();
+    if (record.expires_at < now) {
+      this.destroy(id);
+      return null;
+    }
+    let data = {};
+    try {
+      data = JSON.parse(record.payload);
+    } catch (e) {
+    }
+    return {
+      id,
+      userId: record.user_id,
+      data,
+      expiresAt: record.expires_at
+    };
+  }
+  async destroy(id) {
+    const deleted = await SessionModel.deleteById(id);
+    return deleted > 0;
+  }
+  async cleanup() {
+    const now = Date.now();
+    await SessionModel.query().where("expires_at", "<", now).delete();
+  }
+}
+
 // src/auth/Auth.ts
 async function hashPassword(password) {
   return Bun.password.hash(password, {
@@ -28115,7 +28354,7 @@ function roles(...allowedRoles) {
   };
 }
 
-class SessionStore {
+class MemorySessionDriver {
   sessions = new Map;
   generateId() {
     return `sess_${Date.now().toString(36)}_${crypto.randomUUID().replace(/-/g, "")}`;
@@ -28151,12 +28390,37 @@ class SessionStore {
     }
   }
 }
+
+class SessionStore {
+  driver;
+  constructor(driver) {
+    this.driver = driver || new MemorySessionDriver;
+  }
+  useDatabase() {
+    this.driver = new DatabaseSessionDriver;
+  }
+  use(driver) {
+    this.driver = driver;
+  }
+  async create(userId, data = {}, maxAge = 86400000) {
+    return this.driver.create(userId, data, maxAge);
+  }
+  async get(id) {
+    return this.driver.get(id);
+  }
+  async destroy(id) {
+    return this.driver.destroy(id);
+  }
+  async cleanup() {
+    return this.driver.cleanup();
+  }
+}
 var sessionStore = new SessionStore;
 function sessionAuth(cookieName = "canx_session") {
   return async (req, res, next) => {
     const sessionId = req.cookie(cookieName);
     if (sessionId) {
-      const session = sessionStore.get(sessionId);
+      const session = await sessionStore.get(sessionId);
       if (session) {
         req.context.set("session", session);
         req.context.set("user", { sub: session.userId, ...session.data });
@@ -28263,6 +28527,11 @@ class TableBuilder {
       this.columns[this.columns.length - 1].unique = true;
     return this;
   }
+  primary() {
+    if (this.columns.length)
+      this.columns[this.columns.length - 1].primary = true;
+    return this;
+  }
   index() {
     if (this.columns.length)
       this.columns[this.columns.length - 1].index = true;
@@ -28286,11 +28555,16 @@ class TableBuilder {
     return this;
   }
   toSQL() {
+    const driver = getCurrentDriver();
     const cols = this.columns.map((col) => {
       let sql = `\`${col.name}\` `;
       switch (col.type) {
         case "id":
-          sql += "BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY";
+          if (driver === "sqlite") {
+            sql += "INTEGER PRIMARY KEY AUTOINCREMENT";
+          } else {
+            sql += "BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY";
+          }
           break;
         case "string":
           sql += `VARCHAR(${col.length || 255})`;
@@ -28299,10 +28573,10 @@ class TableBuilder {
           sql += "TEXT";
           break;
         case "int":
-          sql += col.unsigned ? "INT UNSIGNED" : "INT";
+          sql += col.unsigned ? driver === "sqlite" ? "INTEGER" : "INT UNSIGNED" : "INT";
           break;
         case "bigint":
-          sql += col.unsigned ? "BIGINT UNSIGNED" : "BIGINT";
+          sql += col.unsigned ? driver === "sqlite" ? "INTEGER" : "BIGINT UNSIGNED" : "BIGINT";
           break;
         case "float":
           sql += "FLOAT";
@@ -28311,7 +28585,7 @@ class TableBuilder {
           sql += `DECIMAL(${col.length || 10}, 2)`;
           break;
         case "boolean":
-          sql += "TINYINT(1)";
+          sql += driver === "sqlite" ? "INTEGER" : "TINYINT(1)";
           break;
         case "date":
           sql += "DATE";
@@ -28338,6 +28612,8 @@ class TableBuilder {
         }
         if (col.unique)
           sql += " UNIQUE";
+        if (col.primary)
+          sql += " PRIMARY KEY";
       }
       return sql;
     });
@@ -28350,10 +28626,11 @@ class TableBuilder {
         fk += ` ON UPDATE ${ref.onUpdate}`;
       return fk;
     });
+    const suffix = driver === "sqlite" ? "" : " ENGINE=InnoDB DEFAULT CHARSET=utf8mb4";
     return `CREATE TABLE \`${this.tableName}\` (
   ${[...cols, ...fks].join(`,
   `)}
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`;
+)${suffix}`;
   }
 }
 var Schema2 = {
@@ -28375,10 +28652,20 @@ var Schema2 = {
     console.log(`[Migration] Renamed table: ${from} -> ${to}`);
   },
   async hasTable(table) {
+    const driver = getCurrentDriver();
+    if (driver === "sqlite") {
+      const result2 = await query(`SELECT count(*) as count FROM sqlite_master WHERE type='table' AND name='${table}'`);
+      return (result2[0]?.count || result2[0]?.["count(*)"]) > 0;
+    }
     const result = await query(`SHOW TABLES LIKE '${table}'`);
     return result.length > 0;
   },
   async hasColumn(table, column) {
+    const driver = getCurrentDriver();
+    if (driver === "sqlite") {
+      const result2 = await query(`PRAGMA table_info(${table})`);
+      return result2.some((c) => c.name === column);
+    }
     const result = await query(`SHOW COLUMNS FROM \`${table}\` LIKE '${column}'`);
     return result.length > 0;
   }
@@ -28421,7 +28708,7 @@ class Migrator {
     for (const migration of pending) {
       console.log(`[Migration] Running: ${migration.name}`);
       await migration.up();
-      await execute("INSERT INTO migrations (name, batch, executed_at) VALUES (?, ?, NOW())", [migration.name, batch]);
+      await execute("INSERT INTO migrations (name, batch, executed_at) VALUES (?, ?, CURRENT_TIMESTAMP)", [migration.name, batch]);
     }
     console.log(`[Migration] Completed ${pending.length} migrations.`);
   }
@@ -30758,6 +31045,9 @@ function validate(data, schema) {
       if (name !== "required" && (value === undefined || value === null || value === "")) {
         continue;
       }
+      if (["unique", "exists"].includes(name)) {
+        continue;
+      }
       let valid = false;
       if (validators[name]) {
         valid = validators[name](value);
@@ -30781,8 +31071,89 @@ function validate(data, schema) {
   }
   return { valid: errors2.size === 0, errors: errors2, data: validData };
 }
-function validateAsync(data, schema) {
-  return Promise.resolve(validate(data, schema));
+var asyncValidators = {
+  unique: async (v, p) => {
+    if (!p)
+      return false;
+    const [table, column, exceptId, idColumn = "id"] = p.split(",").map((s) => s.trim());
+    let sql = `SELECT COUNT(*) as count FROM ${table} WHERE ${column} = ?`;
+    const params = [v];
+    if (exceptId) {
+      sql += ` AND ${idColumn} != ?`;
+      params.push(exceptId);
+    }
+    try {
+      const rows = await query(sql, params);
+      return (rows[0]?.count || 0) === 0;
+    } catch (e) {
+      console.error("[Validator] Database error in unique:", e);
+      return false;
+    }
+  },
+  exists: async (v, p) => {
+    if (!p)
+      return false;
+    const [table, column = "id"] = p.split(",").map((s) => s.trim());
+    const sql = `SELECT COUNT(*) as count FROM ${table} WHERE ${column} = ?`;
+    try {
+      const rows = await query(sql, [v]);
+      return (rows[0]?.count || 0) > 0;
+    } catch (e) {
+      console.error("[Validator] Database error in exists:", e);
+      return false;
+    }
+  }
+};
+var defaultAsyncMessages = {
+  unique: "Field {field} has already been taken",
+  exists: "Selected {field} is invalid"
+};
+async function validateAsync(data, schema) {
+  const errors2 = new Map;
+  const validData = {};
+  const syncResult = validate(data, schema);
+  if (!syncResult.valid) {
+    syncResult.errors.forEach((msgs, field) => errors2.set(field, msgs));
+  } else {
+    Object.assign(validData, syncResult.data);
+  }
+  for (const [field, rules] of Object.entries(schema)) {
+    const value = data[field];
+    let ruleList;
+    let customMessages = {};
+    if (Array.isArray(rules)) {
+      ruleList = rules;
+    } else if (typeof rules === "object") {
+      ruleList = rules.rules;
+      customMessages = rules.messages || {};
+    } else {
+      ruleList = [rules];
+    }
+    for (const rule of ruleList) {
+      const { name, param } = parseRule(rule);
+      if (!asyncValidators[name] || (value === undefined || value === null || value === "")) {
+        continue;
+      }
+      if (errors2.has(field))
+        continue;
+      try {
+        const valid = await asyncValidators[name](value, param);
+        if (!valid) {
+          const msg = customMessages[name] || defaultAsyncMessages[name] || defaultMessages[name] || `Validation failed for {field}`;
+          const finalMsg = msg.replace("{field}", field).replace("{param}", param || "");
+          const existing = errors2.get(field) || [];
+          existing.push(finalMsg);
+          errors2.set(field, existing);
+        }
+      } catch (err) {
+        console.error("[Validator] Unexpected error in validateAsync", err);
+      }
+    }
+    if (!errors2.has(field) && value !== undefined) {
+      validData[field] = value;
+    }
+  }
+  return { valid: errors2.size === 0, errors: errors2, data: validData };
 }
 var is = {
   email: (v) => validators.email(v),
@@ -32139,6 +32510,7 @@ export {
   EventServiceProvider,
   EventEmitter,
   Delete,
+  DatabaseSessionDriver,
   DatabaseError,
   Controller,
   Container,