canxjs 1.2.2 → 1.2.4

package/src/mvc/Model.ts

@@ -7,6 +7,7 @@ import type { DatabaseConfig, DatabaseDriver, ModelField, ModelSchema, QueryBuil
 // Database connection pool
 let mysqlPool: any = null;
 let pgPool: any = null;
+let sqliteDb: any = null;
 let currentDriver: DatabaseDriver = 'mysql';
 let dbConfig: DatabaseConfig | null = null;
 
@@ -39,12 +40,21 @@ export async function initDatabase(config: DatabaseConfig): Promise<void> {
       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');
   }
 }
 
 export async function closeDatabase(): Promise<void> {
   if (mysqlPool) { await mysqlPool.end(); mysqlPool = null; }
   if (pgPool) { await pgPool.end(); pgPool = null; }
+  if (sqliteDb) { sqliteDb.close(); sqliteDb = null; }
+}
+
+export function getCurrentDriver(): DatabaseDriver {
+  return currentDriver;
 }
 
 async function query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
@@ -59,6 +69,12 @@ async function query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
     const pgSql = sql.replace(/\?/g, () => `$${++idx}`);
     const result = await pgPool.query(pgSql, params);
     return result.rows as T[];
+  } else if (currentDriver === 'sqlite' && sqliteDb) {
+    const query = sqliteDb.query(sql);
+    // bun:sqlite uses $1, $2 or named params, but handle simple ? for compatibility?
+    // Bun sqlite actually supports ? binding since recent versions or via .all(...params)
+    // Let's try direct binding.
+    return query.all(...params) as T[];
   }
   throw new Error('No database connection');
 }
@@ -74,12 +90,28 @@ async function execute(sql: string, params: any[] = []): Promise<{ affectedRows:
     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 query = sqliteDb.query(sql);
+    const result = query.run(...params);
+    return { affectedRows: result.changes, insertId: result.lastInsertRowid };
   }
   throw new Error('No database connection');
 }
 
+// Relation Metadata interface
+interface RelationInfo {
+  type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+  relatedClass: any;
+  foreignKey: string;
+  localKey?: string;
+  ownerKey?: string;
+  pivotTable?: string;
+  foreignPivotKey?: string;
+  relatedPivotKey?: string;
+}
+
 // Query Builder implementation
-class QueryBuilderImpl<T> implements QueryBuilder<T> {
+export class QueryBuilderImpl<T> implements QueryBuilder<T> {
   private table: string;
   private selectCols: string[] = ['*'];
   private whereClauses: string[] = [];
@@ -90,8 +122,21 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
   private groupClauses: string[] = [];
   private havingClauses: string[] = [];
   private bindings: any[] = [];
-
-  constructor(table: string) { this.table = table; }
+  
+  // Model mapping
+  private modelClass?: any;
+  
+  // Eager Loading
+  private withRelations: string[] = [];
+  // Internal relation info attached by relationship methods
+  public _relationInfo?: RelationInfo;
+
+  constructor(table: string, modelClass?: any) { 
+    this.table = table;
+    this.modelClass = modelClass;
+  }
+  
+  // ... existing methods ...
 
   select(...cols: any[]): this { this.selectCols = cols.length ? cols : ['*']; return this; }
   
@@ -100,8 +145,12 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
     this.bindings.push(val);
     return this;
   }
-
+  
   whereIn(col: any, vals: any[]): this {
+    if (vals.length === 0) {
+       this.whereClauses.push('1 = 0'); // False condition if empty
+       return this;
+    }
     this.whereClauses.push(`${String(col)} IN (${vals.map(() => '?').join(',')})`);
     this.bindings.push(...vals);
     return this;
@@ -125,7 +174,7 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
     this.orderClauses.push(`${String(col)} ${dir.toUpperCase()}`);
     return this;
   }
-
+  
   limit(n: number): this { this.limitVal = n; return this; }
   offset(n: number): this { this.offsetVal = n; return this; }
 
@@ -133,7 +182,7 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
     this.joinClauses.push(`INNER JOIN ${table} ON ${first} ${op} ${second}`);
     return this;
   }
-
+  
   leftJoin(table: string, first: string, op: string, second: string): this {
     this.joinClauses.push(`LEFT JOIN ${table} ON ${first} ${op} ${second}`);
     return this;
@@ -146,6 +195,12 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
     this.bindings.push(val);
     return this;
   }
+  
+  // Eager Loading
+  with(...relations: string[]): this {
+    this.withRelations.push(...relations);
+    return this;
+  }
 
   private buildSelect(): string {
     let sql = `SELECT ${this.selectCols.join(', ')} FROM ${this.table}`;
@@ -159,11 +214,129 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
     return sql;
   }
 
-  async get(): Promise<T[]> { return query<T>(this.buildSelect(), this.bindings); }
-  async first(): Promise<T | null> { this.limitVal = 1; const r = await this.get(); return r[0] || null; }
-  async count(): Promise<number> { this.selectCols = ['COUNT(*) as count']; const r = await this.get(); return (r[0] as any)?.count || 0; }
-  async sum(col: any): Promise<number> { this.selectCols = [`SUM(${String(col)}) as sum`]; const r = await this.get(); return (r[0] as any)?.sum || 0; }
-  async avg(col: any): Promise<number> { this.selectCols = [`AVG(${String(col)}) as avg`]; const r = await this.get(); return (r[0] as any)?.avg || 0; }
+  async get(): Promise<T[]> { 
+    const rows = await query<any>(this.buildSelect(), this.bindings);
+    let results: T[] = rows as T[];
+    
+    if (this.modelClass) {
+      results = rows.map(r => new this.modelClass().fill(r));
+    }
+    
+    // Process Eager Loading
+    if (this.withRelations.length > 0 && this.modelClass && results.length > 0) {
+      await this.eagerLoad(results);
+    }
+    
+    return results;
+  }
+  
+  async eagerLoad(results: any[]) {
+    // We assume results are instances of modelClass
+    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;
+      }
+      
+      // Get relation definition by calling the method
+      // The method returns a QueryBuilder with _relationInfo attached
+      const relationQuery = instance[relationName]();
+      const info = (relationQuery as any)._relationInfo as 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;
+        
+        // Ensure unique IDs
+        const uniqueIds = [...new Set(parentIds)];
+        
+        // Fetch related
+        const relatedResults = await info.relatedClass.query().whereIn(foreignKey, uniqueIds).get();
+        
+        // Map back
+        for (const parent of results) {
+          const parentId = parent[localKey];
+          if (info.type === 'hasMany') {
+            parent.startRelation(relationName);
+            parent.relations[relationName] = relatedResults.filter((r: any) => r[foreignKey] == parentId);
+          } else {
+             // hasOne
+             parent.startRelation(relationName);
+             parent.relations[relationName] = relatedResults.find((r: any) => r[foreignKey] == parentId) || null;
+          }
+        }
+        
+      } else if (info.type === 'belongsTo') {
+         const foreignKey = info.foreignKey; // e.g. user_id on Post
+         const ownerKey = info.ownerKey || 'id'; // e.g. id on User
+         
+         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: any) => r[ownerKey] == relatedId) || null;
+         }
+      } else if (info.type === 'belongsToMany') {
+          // Pivot logic
+          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)];
+
+          // 1. Get pivot rows
+          // SELECT * FROM pivot WHERE foreignPivotKey IN (ids)
+          const pivotSql = `SELECT * FROM ${info.pivotTable} WHERE ${info.foreignPivotKey} IN (${uniqueIds.map(() => '?').join(',')})`;
+          const pivotRows = await query<any>(pivotSql, uniqueIds);
+          
+          if (pivotRows.length === 0) {
+             for (const parent of results) {
+                parent.startRelation(relationName);
+                parent.relations[relationName] = [];
+             }
+             continue;
+          }
+          
+          // 2. Get related rows
+          const relatedIds = pivotRows.map(r => r[info.relatedPivotKey!]);
+          const uniqueRelatedIds = [...new Set(relatedIds)];
+          const relatedResults = await info.relatedClass.query().whereIn('id', uniqueRelatedIds).get();
+          
+          // 3. Map back
+          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: any) => myRelatedIds.includes(r.id));
+          }
+      }
+    }
+  }
+  
+  async first(): Promise<T | null> { 
+    this.limitVal = 1; 
+    const rows = await this.get();
+    return rows[0] || null; 
+  }
+  
+  async count(): Promise<number> { this.selectCols = ['COUNT(*) as count']; const r = await query<any>(this.buildSelect(), this.bindings); return (r[0] as any)?.count || 0; }
+  async sum(col: any): Promise<number> { this.selectCols = [`SUM(${String(col)}) as sum`]; const r = await query<any>(this.buildSelect(), this.bindings); return (r[0] as any)?.sum || 0; }
+  async avg(col: any): Promise<number> { this.selectCols = [`AVG(${String(col)}) as avg`]; const r = await query<any>(this.buildSelect(), this.bindings); return (r[0] as any)?.avg || 0; }
 
   async insert(data: Partial<T> | Partial<T>[]): Promise<T> {
     const items = Array.isArray(data) ? data : [data];
@@ -172,6 +345,12 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
     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 modelClass is set, return instance?
+    // insert() signature returns T.
+    if (this.modelClass) {
+       return new this.modelClass().fill({ ...(items[0] as any), id: result.insertId });
+    }
     return { ...(items[0] as any), id: result.insertId } as T;
   }
 
@@ -196,47 +375,169 @@ class QueryBuilderImpl<T> implements QueryBuilder<T> {
 }
 
 // Base Model class
-export abstract class Model<T extends Record<string, any> = any> {
+export abstract class Model {
   protected static tableName: string;
   protected static primaryKey: string = 'id';
   protected static timestamps: boolean = true;
+  
+  // Instance properties
+  [key: string]: any;
+  
+  // Relations storage
+  public relations: Record<string, any> = {};
 
-  static table<T>(): QueryBuilder<T> {
-    return new QueryBuilderImpl<T>(this.tableName);
+  constructor(data?: any) {
+    if (data) Object.assign(this, data);
   }
 
-  static async find<T>(id: number | string): Promise<T | null> {
-    return new QueryBuilderImpl<T>(this.tableName).where(this.primaryKey, '=', id).first();
+  // Static helper to get entries as Instances
+  static table<T extends Model>(this: new () => T): QueryBuilder<T> {
+    return new QueryBuilderImpl<T>((this as any).tableName, this);
   }
 
-  static async all<T>(): Promise<T[]> {
-    return new QueryBuilderImpl<T>(this.tableName).get();
+  // Find by ID - returns Instance
+  static async find<T extends Model>(this: { new (): T } & typeof Model, id: number | string): Promise<T | null> {
+    return this.table<T>().where(this.primaryKey, '=', id).first();
   }
 
-  static async create<T>(data: Partial<T>): Promise<T> {
+  // Chainable query builder
+  static query<T extends Model>(this: { new (): T } & typeof Model): QueryBuilder<T> {
+    return new QueryBuilderImpl<T>(this.tableName, this);
+  }
+
+  static async all<T extends Model>(this: { new (): T } & typeof Model): Promise<T[]> {
+    return this.query<T>().get();
+  }
+
+  // Init relation storage
+  startRelation(name: string) {
+    if (!this.relations) this.relations = {};
+  }
+  
+  // Lazy load relations
+  async load(...relations: string[]): Promise<this> {
+     // Create a builder just to use its eagerLoad ability
+     const builder = new QueryBuilderImpl<any>((this.constructor as any).tableName, this.constructor);
+     builder.with(...relations);
+     await builder.eagerLoad([this]);
+     return this;
+  }
+  
+  // Start Eager Loading
+  static with<T extends Model>(this: { new (): T } & typeof Model, ...relations: string[]): QueryBuilder<T> {
+    return this.query<T>().with(...relations);
+  }
+
+  // Helper to fill data (chainable)
+  fill(data: any): this {
+    Object.assign(this, data);
+    return this;
+  }
+
+  // Create - returns Instance
+  static async create<T extends Model>(this: { new (): T } & typeof Model, data: Partial<T>): Promise<T> {
     if (this.timestamps) {
       const now = new Date().toISOString().slice(0, 19).replace('T', ' ');
       (data as any).created_at = now;
       (data as any).updated_at = now;
     }
-    return new QueryBuilderImpl<T>(this.tableName).insert(data);
+    return this.query<T>().insert(data);
   }
 
   static async updateById<T>(id: number | string, data: Partial<T>): Promise<number> {
     if (this.timestamps) {
       (data as any).updated_at = new Date().toISOString().slice(0, 19).replace('T', ' ');
     }
-    return new QueryBuilderImpl<T>(this.tableName).where(this.primaryKey, '=', id).update(data);
+    return new QueryBuilderImpl<any>(this.tableName).where(this.primaryKey, '=', id).update(data);
   }
 
   static async deleteById(id: number | string): Promise<number> {
     return new QueryBuilderImpl<any>(this.tableName).where(this.primaryKey, '=', id).delete();
   }
+  
+  // ============================================
+  // Relationships
+  // ============================================
+
+  // HasOne: User has one Profile
+  hasOne<R extends Model>(related: { new (): R } & typeof Model, foreignKey?: string, localKey: string = 'id'): Promise<R | null> {
+    const fk = foreignKey || `${this.constructor.name.toLowerCase()}_id`;
+    const pk = (this as any)[localKey];
+    
+    // We need to return a Promise that behaves like the query result BUT also carries metadata
+    // This is tricky because we are returning Promise<R|null> here for direct usage, 
+    // but eager loading needs the QueryBuilder.
+    // However, in our eagerLoad impl, we call this method and check `_relationInfo` on the returned object.
+    // If we return a Promise, we must attach _relationInfo to the Promise!
+    
+    const qb = related.query<R>();
+    const info: RelationInfo = { type: 'hasOne', relatedClass: related, foreignKey: fk, localKey };
+    (qb as any)._relationInfo = info;
+    
+    const promise = qb.where(fk, '=', pk).first();
+    (promise as any)._relationInfo = info; // Attach to promise effectively
+    return promise;
+  }
+
+  // HasMany: User has many Posts
+  hasMany<R extends Model>(related: { new (): R } & typeof Model, foreignKey?: string, localKey: string = 'id'): QueryBuilder<R> {
+    const fk = foreignKey || `${this.constructor.name.toLowerCase()}_id`;
+    const pk = (this as any)[localKey];
+    
+    const qb = related.query<R>().where(fk, '=', pk);
+    const info: RelationInfo = { type: 'hasMany', relatedClass: related, foreignKey: fk, localKey };
+    (qb as any)._relationInfo = info;
+    return qb;
+  }
 
-  static query<T>(): QueryBuilder<T> {
-    return new QueryBuilderImpl<T>(this.tableName);
+  // BelongsTo: Post belongs to User
+  belongsTo<R extends Model>(related: { new (): R } & typeof Model, foreignKey?: string, ownerKey: string = 'id'): Promise<R | null> {
+    const fk = foreignKey || `${related.name.toLowerCase()}_id`;
+    const val = (this as any)[fk];
+    
+    const qb = related.query<R>();
+    const info: RelationInfo = { type: 'belongsTo', relatedClass: related, foreignKey: fk, ownerKey };
+    (qb as any)._relationInfo = info;
+
+    const promise = qb.where(ownerKey, '=', val).first();
+    (promise as any)._relationInfo = info;
+    return promise;
+  }
+  
+  // BelongsToMany: User belongsForMany Roles (through user_roles)
+  belongsToMany<R extends Model>(
+    related: { new (): R } & typeof Model, 
+    pivotTable: string,
+    foreignPivotKey?: string, 
+    relatedPivotKey?: string
+  ): QueryBuilder<R> {
+     // User belongsToMany Role
+     // pivot: user_roles
+     // foreignPivotKey: user_id (this model)
+     // relatedPivotKey: role_id (related model)
+     
+     const foreignKey = foreignPivotKey || `${this.constructor.name.toLowerCase()}_id`;
+     const relatedKey = relatedPivotKey || `${related.name.toLowerCase()}_id`;
+     const pk = (this as any).id;
+     
+     const qb = related.query<R>();
+     const info: RelationInfo = { 
+       type: 'belongsToMany', 
+       relatedClass: related,
+       foreignKey: '', // Not used for belongsToMany but required by interface
+       pivotTable, 
+       foreignPivotKey: foreignKey, 
+       relatedPivotKey: relatedKey 
+     };
+     (qb as any)._relationInfo = info;
+
+     // SELECT roles.* FROM roles INNER JOIN pivot ON pivot.role_id = roles.id WHERE pivot.user_id = ?
+     return qb
+       .select(`${related.tableName}.*`)
+       .join(pivotTable, `${pivotTable}.${relatedKey}`, '=', `${related.tableName}.id`)
+       .where(`${pivotTable}.${foreignKey}`, '=', pk);
   }
 }
 
-export { query, execute, QueryBuilderImpl };
+export { query, execute };
 export default Model;

package/src/types/index.ts

@@ -241,6 +241,7 @@ export interface QueryBuilder<T> {
   update: (data: Partial<T>) => Promise<number>;
   delete: () => Promise<number>;
   raw: (sql: string, bindings?: unknown[]) => Promise<unknown>;
+  with: (...relations: string[]) => QueryBuilder<T>;
 }
 
 // ============================================

package/src/utils/Validator.ts

@@ -77,6 +77,11 @@ export function validate(data: Record<string, unknown>, schema: ValidationSchema
       if (name !== 'required' && (value === undefined || value === null || value === '')) {
         continue;
       }
+      
+      // Skip async rules
+      if (['unique', 'exists'].includes(name)) {
+        continue;
+      }
 
       let valid = false;
       if (validators[name]) {
@@ -105,8 +110,125 @@ export function validate(data: Record<string, unknown>, schema: ValidationSchema
   return { valid: errors.size === 0, errors, data: validData };
 }
 
-export function validateAsync(data: Record<string, unknown>, schema: ValidationSchema): Promise<ValidationResult> {
-  return Promise.resolve(validate(data, schema));
+import { query } from '../mvc/Model';
+
+type AsyncValidatorFn = (value: unknown, param?: string) => Promise<boolean>;
+
+const asyncValidators: Record<string, AsyncValidatorFn> = {
+  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: any[] = [v];
+    
+    if (exceptId) {
+      sql += ` AND ${idColumn} != ?`;
+      params.push(exceptId);
+    }
+    
+    
+    
+    try {
+      const rows = await query<{count: number}>(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<{count: number}>(sql, [v]);
+      return (rows[0]?.count || 0) > 0;
+    } catch (e) {
+      console.error('[Validator] Database error in exists:', e);
+      return false;
+    }
+  },
+};
+
+const defaultAsyncMessages: Record<string, string> = {
+  unique: 'Field {field} has already been taken',
+  exists: 'Selected {field} is invalid',
+};
+
+export async function validateAsync(data: Record<string, unknown>, schema: ValidationSchema): Promise<ValidationResult> {
+  const errors = new Map<string, string[]>();
+  const validData: Record<string, unknown> = {};
+
+  // Run sync validation first
+  const syncResult = validate(data, schema);
+  if (!syncResult.valid) {
+    // If sync validation fails, we might still want to run async, 
+    // but usually if format is wrong, checking DB is waste.
+    // However, mixing errors is good.
+    // Let's copy errors
+    syncResult.errors.forEach((msgs, field) => errors.set(field, msgs));
+  } else {
+    Object.assign(validData, syncResult.data);
+  }
+
+  // Check async rules
+  for (const [field, rules] of Object.entries(schema)) {
+    const value = data[field];
+    
+    // Get rules list
+    let ruleList: ValidationRule[];
+    let customMessages: Record<string, string> = {};
+
+    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);
+      
+      // We only care about async validators here
+      // And we skip if value is empty/null (unless it's required, but sync validate handled required)
+      if (
+        !asyncValidators[name] || 
+        (value === undefined || value === null || value === '')
+      ) {
+        continue;
+      }
+
+      // If sync validation already failed for this field, usually we skip checking DB
+      if (errors.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 = errors.get(field) || [];
+            existing.push(finalMsg);
+            errors.set(field, existing);
+          }
+      } catch (err) {
+          console.error('[Validator] Unexpected error in validateAsync', err);
+      }
+    }
+    
+    if (!errors.has(field) && value !== undefined) {
+      validData[field] = value;
+    }
+  }
+
+  return { valid: errors.size === 0, errors, data: validData };
 }
 
 // Quick validators