forj 0.0.11 → 0.0.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "type": "module",
   "main": "src/index.ts",
   "files": ["src"],

package/src/migrations/blueprint.ts

@@ -1,5 +1,6 @@
 import Column from './column'
 import ForeignKey from './foreign-key'
+import { tableName } from '../utils'
 import type {
   ColumnDefinition, IndexDefinition, ForeignKeyDefinition,
 } from './types'
@@ -13,7 +14,7 @@ export class Blueprint {
   #renameColumns: Map<string, string> = new Map()
 
   constructor(table: string) {
-    this.#table = table
+    this.#table = tableName(table)
   }
 
   #column(definition: ColumnDefinition) {
@@ -22,96 +23,108 @@ export class Blueprint {
     return new Column(column)
   }
 
-  id(name: string = 'id') { // Auto-increment ID (bigint unsigned)
-    return this.#column({ name, type: 'INTEGER', autoIncrement: true, primary: true, nullable: false })
+  id(name: string = 'id') {
+    return this.#column({ name, type: 'INTEGER', primary: true, nullable: true })
   }
 
-  string(name: string, length: number = 255) {
-    return this.#column({ name, type: 'VARCHAR', length, nullable: false })
+  string(name: string, length: number = 0) {
+    return this.#column({ name, type: 'VARCHAR', length })
   }
 
   text(name: string) {
-    return this.#column({ name, type: 'TEXT', nullable: false })
+    return this.#column({ name, type: 'TEXT' })
   }
 
   int(name: string) {
-    return this.#column({ name, type: 'INTEGER', nullable: false })
+    return this.#column({ name, type: 'INTEGER' })
   }
   integer(name: string) {
     return this.int(name)
   }
   real(name: string) {
-    return this.#column({ name, type: 'REAL', nullable: false })
+    return this.#column({ name, type: 'REAL' })
   }
   numeric(name: string) {
-    return this.#column({ name, type: 'NUMERIC', nullable: false })
+    return this.#column({ name, type: 'NUMERIC' })
   }
 
   // bigInteger(name: string) {
-  //   return this.#column({ name, type: 'BIGINT', nullable: false })
+  //   return this.#column({ name, type: 'BIGINT' })
   // }
 
   // tinyInteger(name: string) {
-  //   return this.#column({ name, type: 'TINYINT', nullable: false })
+  //   return this.#column({ name, type: 'TINYINT' })
   // }
 
   boolean(name: string) {
-    return this.#column({ name, type: 'INTEGER', nullable: false })
+    return this.#column({ name, type: 'INTEGER' })
   }
 
   // decimal(name: string, precision: number = 8, scale: number = 2) {
-  //   return this.#column({ name, type: `DECIMAL(${precision},${scale})`, nullable: false })
+  //   return this.#column({ name, type: `DECIMAL(${precision},${scale})` })
   // }
 
   // float(name: string) {
-  //   return this.#column({ name, type: 'FLOAT', nullable: false })
+  //   return this.#column({ name, type: 'FLOAT' })
   // }
 
   // double(name: string) {
-  //   return this.#column({ name, type: 'DOUBLE', nullable: false })
+  //   return this.#column({ name, type: 'DOUBLE' })
   // }
 
   // date(name: string) {
-  //   return this.#column({ name, type: 'DATE', nullable: false })
+  //   return this.#column({ name, type: 'DATE' })
   // }
 
   // dateTime(name: string) {
-  //   return this.#column({ name, type: 'DATETIME', nullable: false })
+  //   return this.#column({ name, type: 'DATETIME' })
   // }
 
   // timestamp(name: string) {
-  //   return this.#column({ name, type: 'TIMESTAMP', nullable: false })
+  //   return this.#column({ name, type: 'TIMESTAMP' })
   // }
 
   // time(name: string) {
-  //   return this.#column({ name, type: 'TIME', nullable: false })
+  //   return this.#column({ name, type: 'TIME' })
   // }
 
-  json(name: string) {
-    return this.#column({ name, type: 'JSON', nullable: false })
-  }
+  // json(name: string) {
+  //   return this.#column({ name, type: 'JSON' })
+  // }
 
-  enum(name: string, values: string[]) {
-    return this.#column({ name, type: `ENUM(${values.map(v => `'${v}'`).join(', ')})`, nullable: false })
+  enum(name: string, values: string[] | number[]) {
+    return this.#column({
+      name,
+      type: values.every(v => typeof v == 'string') ? 'TEXT' : (values.every(v => Number.isInteger(v)) ? 'INTEGER' : 'REAL'),
+      // TODO:
+      // Checking floating-point numbers can be problematic due to the precision of REAL numbers
+      // SQLite might store 0.5 as 0.4999999 or 0.5000001, causing the check to fail
+      // Maybe works:
+      //   rate NUMERIC(3,1) NOT NULL DEFAULT 0 CHECK(
+      //     rate IN (0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5)
+      //   )
+      raw: `CHECK(${name} IN (${values.map(v => typeof v == 'string' ? `'${v.replace(/'/g, "\\'")}'` : v).join(', ')}))`,
+    })
   }
 
   blob(name: string) {
-    return this.#column({ name, type: 'BLOB', nullable: false })
+    return this.#column({ name, type: 'BLOB' })
   }
 
-  timestamps() {
-    this.#column({ name: 'created_at', type: 'TEXT', nullable: false })
-    this.#column({ name: 'updated_at', type: 'TEXT', nullable: false })
+  timestamps(columnType: 'int' | 'date' = 'int') {
+    const isInt = columnType == 'int'
+    const type = isInt ? 'INTEGER' : 'DATETIME'
+    this.#column({ name: 'created_at', type, raw: 'DEFAULT '+ (isInt ? '(unixepoch())' : 'CURRENT_TIMESTAMP') })
+    this.#column({ name: 'updated_at', type, nullable: true })
     return this
   }
 
-  softDelete(name: string = 'deleted_at') {
-    this.#column({ name, type: 'TEXT', nullable: true })
+  softDelete(columnType: 'int' | 'date' = 'int', name: string = 'deleted_at') {
+    this.#column({ name, type: columnType == 'int' ? 'INTEGER' : 'DATETIME', nullable: true })
     return this
   }
-
-  softDeletes(name: string = 'deleted_at') {
-    return this.softDelete(name)
+  softDeletes(columnType: 'int' | 'date' = 'int', name: string = 'deleted_at') {
+    return this.softDelete(columnType, name)
   }
 
   foreign(column: string) {

package/src/migrations/builder.ts

@@ -1,15 +1,16 @@
 import { Blueprint } from './blueprint'
+import { tableName, tableSlug } from '../utils'
 import type { ColumnDefinition, IndexDefinition, ForeignKeyDefinition } from './types'
 
 export default class SchemaBuilder {
-  static create(blueprint: Blueprint): string {
-    const tableName = blueprint.table
+  static create(blueprint: Blueprint, exist: boolean = false): string {
+    const table = blueprint.table
     const columns = blueprint.columns
     const indexes = blueprint.indexes
     const foreignKeys = blueprint.foreignKeys
 
     const columnDefinitions = columns.map(col => this.#column(col))
-    const indexDefinitions = indexes.map(idx => this.#index(idx, tableName))
+    const indexDefinitions = indexes.map(idx => this.#index(idx, table))
     const foreignKeyDefinitions = foreignKeys.map(fk => this.#foreignKey(fk))
 
     const allDefinitions = [
@@ -18,31 +19,31 @@ export default class SchemaBuilder {
       ...foreignKeyDefinitions
     ].filter(Boolean)
 
-    return `CREATE TABLE ${tableName} (\n  ${allDefinitions.join(',\n  ')}\n);`
+    return `CREATE TABLE ${exist ? 'IF NOT EXISTS ' : ''}${table} (\n  ${allDefinitions.join(',\n  ')}\n);`
   }
 
   static alter(blueprint: Blueprint): string[] {
-    const tableName = blueprint.table
+    const table = blueprint.table
     const statements: string[] = []
 
     const columns = blueprint.columns
     if (columns.length > 0)
-      columns.forEach(col => statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${this.#column(col)};`))
+      columns.forEach(col => statements.push(`ALTER TABLE ${table} ADD COLUMN ${this.#column(col)};`))
 
     const dropColumns = blueprint.dropColumns
-    dropColumns.forEach(col => statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${col};`))
+    dropColumns.forEach(col => statements.push(`ALTER TABLE ${table} DROP COLUMN ${col};`))
 
     const renameColumns = blueprint.renameColumns
-    renameColumns.forEach((newName, oldName) => statements.push(`ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`))
+    renameColumns.forEach((newName, oldName) => statements.push(`ALTER TABLE ${table} RENAME COLUMN ${oldName} TO ${newName};`))
 
     const indexes = blueprint.indexes
     indexes.forEach(idx => {
-      const indexSql = this.#indexStatement(idx, tableName)
+      const indexSql = this.#indexStatement(idx, table)
       if (indexSql) statements.push(indexSql)
     })
 
     const foreignKeys = blueprint.foreignKeys
-    foreignKeys.forEach(fk => statements.push(`ALTER TABLE ${tableName} ADD ${this.#foreignKey(fk)};`))
+    foreignKeys.forEach(fk => statements.push(`ALTER TABLE ${table} ADD ${this.#foreignKey(fk)};`))
 
     return statements
   }
@@ -62,36 +63,41 @@ export default class SchemaBuilder {
     // if (column.unsigned)
     //   sql += ' UNSIGNED'
 
-    if (column.nullable) {
-      sql += ' NULL'
-    } else {
+    if (!column.nullable)
       sql += ' NOT NULL'
-    }
 
     if (column.default !== undefined) {
+      sql += ' DEFAULT '
       if (column.default === null) {
-        sql += ' DEFAULT NULL'
-      } else if (typeof column.default == 'string') {
-        sql += ` DEFAULT '${column.default}'`
-      } else if (typeof column.default == 'boolean') {
-        sql += ` DEFAULT ${column.default ? 1 : 0}`
+        sql += 'NULL'
       } else {
-        sql += ` DEFAULT ${column.default}`
+        const type = typeof column.default
+        if (type == 'string') {
+          sql += `'${column.default.replace(/'/g, "\\'")}'`
+        } else if (type == 'boolean') {
+          sql += Number(column.default)
+        } else {
+          sql += `${column.default}`.replace(/''/g, "'\\'")
+        }
       }
     }
 
     if (column.unique)
       sql += ' UNIQUE'
 
+    if (column.raw)
+      sql += ' '+ column.raw
+
     // if (column.comment)
     //   sql += ` COMMENT '${column.comment.replace(/'/g, "''")}'`
 
     return sql
   }
 
-  static #index(index: IndexDefinition, tableName: string): string {
-    const indexName = index.name || `${tableName}_${index.columns.join('_')}_${index.type}`
+  static #index(index: IndexDefinition, table: string): string {
+    const indexName = index.name || tableSlug(table) +`_${index.columns.join('_')}_${index.type}`
     const columns = index.columns.join(', ')
+    table = tableName(table)
 
     switch (index.type) {
       case 'primary':
@@ -105,17 +111,18 @@ export default class SchemaBuilder {
     }
   }
 
-  static #indexStatement(index: IndexDefinition, tableName: string): string {
-    const indexName = index.name || `${tableName}_${index.columns.join('_')}_${index.type}`
+  static #indexStatement(index: IndexDefinition, table: string): string {
+    const indexName = index.name || tableSlug(table) +`_${index.columns.join('_')}_${index.type}`
     const columns = index.columns.join(', ')
+    table = tableName(table)
 
     switch (index.type) {
       case 'primary':
-        return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columns});`
+        return `ALTER TABLE ${table} ADD PRIMARY KEY (${columns});`
       case 'unique':
-        return `CREATE UNIQUE INDEX ${indexName} ON ${tableName} (${columns});`
+        return `CREATE UNIQUE INDEX ${indexName} ON ${table} (${columns});`
       case 'index':
-        return `CREATE INDEX ${indexName} ON ${tableName} (${columns});`
+        return `CREATE INDEX ${indexName} ON ${table} (${columns});`
       default:
         return ''
     }
@@ -133,35 +140,43 @@ export default class SchemaBuilder {
     return sql
   }
 
-  static drop(tableName: string) {
-    return `DROP TABLE ${tableName};`
+  static drop(table: string, exist: boolean = false) {
+    return `DROP TABLE ${exist ? 'IF EXISTS ' : ''}${tableName(table)};`
+  }
+
+  static dropIfExists(table: string) {
+    return this.drop(table, true)
+  }
+
+  static dropView(view: string, exist: boolean = false) {
+    return `DROP VIEW ${exist ? 'IF EXISTS ' : ''}[${tableName(view)}];`
   }
 
-  static dropIfExists(tableName: string) {
-    return `DROP TABLE IF EXISTS ${tableName};`
+  static dropViewIfExists(view: string) {
+    return this.dropView(view, true)
   }
 
   static rename(from: string, to: string) {
-    return `ALTER TABLE ${from} RENAME TO ${to};`
+    return `ALTER TABLE ${tableName(from)} RENAME TO ${tableName(to)};`
   }
 
-  static hasTable(tableName: string) {
-    return `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`
+  static hasTable(table: string) {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName(table)}';`
   }
 
-  static hasColumn(tableName: string, columnName: string) { // TODO refactor..
-    return `PRAGMA table_info(${tableName});`
+  static hasColumn(table: string, columnName: string) { // TODO refactor..
+    return `PRAGMA table_info(${tableName(table)});`
   }
 
   static getAllTables() {
     return `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';`
   }
 
-  static getColumns(tableName: string): string {
-    return `PRAGMA table_info(${tableName});`
+  static getColumns(table: string): string {
+    return `PRAGMA table_info(${tableName(table)});`
   }
 
   static dropAllTables(tables: string[]) {
-    return tables.map(table => `DROP TABLE IF EXISTS ${table};`)
+    return tables.map(table => `DROP TABLE IF EXISTS ${tableName(table)};`)
   }
 }

package/src/migrations/column.ts

@@ -13,8 +13,18 @@ export default class Column {
     return this
   }
 
-  default(value: any) {
-    this.column.default = value
+  default(val: any) {
+    this.column.default = val
+    return this
+  }
+
+  defaultRaw(val: string) {
+    this.column.raw = 'DEFAULT '+ val
+    return this
+  }
+
+  raw(raw: string) {
+    this.column.raw = raw
     return this
   }
 

package/src/migrations/schema.ts

@@ -41,30 +41,42 @@ export class Schema {
   //   this.#addStatement(...sql)
   // }
 
-  static async create(tableName: string, fn: BlueprintFn): Promise<void> {
-    const blueprint = new Blueprint(tableName)
+  static async create(table: string, fn: BlueprintFn, exist: boolean = false): Promise<void> {
+    const blueprint = new Blueprint(table)
     fn(blueprint)
-    await this.#addStatement(Builder.create(blueprint))
+    await this.#addStatement(Builder.create(blueprint, exist))
   }
 
-  static async table(tableName: string, fn: BlueprintFn): Promise<void> {
-    const blueprint = new Blueprint(tableName)
+  static async createIfNotExists(table: string, fn: BlueprintFn): Promise<void> {
+    this.create(table, fn, true)
+  }
+
+  static async table(table: string, fn: BlueprintFn): Promise<void> {
+    const blueprint = new Blueprint(table)
     fn(blueprint)
     await this.#addStatement(Builder.alter(blueprint))
   }
 
-  static async drop(tableName: string): Promise<void> {
-    await this.#addStatement(Builder.drop(tableName))
+  static async drop(table: string): Promise<void> {
+    await this.#addStatement(Builder.drop(table))
   }
 
-  static async dropIfExists(tableName: string): Promise<void> {
-    await this.#addStatement(Builder.dropIfExists(tableName))
+  static async dropIfExists(table: string): Promise<void> {
+    await this.#addStatement(Builder.dropIfExists(table))
   }
 
   static async rename(from: string, to: string): Promise<void> {
     await this.#addStatement(Builder.rename(from, to))
   }
 
+  static async dropView(view: string): Promise<void> {
+    await this.#addStatement(Builder.dropView(view))
+  }
+
+  static async dropViewIfExists(view: string): Promise<void> {
+    await this.#addStatement(Builder.dropViewIfExists(view))
+  }
+
   static async disableForeignKeyConstraints(): Promise<void> {
     this.#foreignKeyConstraintsEnabled = false
     await this.#addStatement('PRAGMA foreign_keys = OFF;')
@@ -92,29 +104,29 @@ export class Schema {
   //   await this.#addStatement(sql)
   // }
 
-  // static async hasTable(tableName: string): Promise<boolean> {
+  // static async hasTable(table: string): Promise<boolean> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
-  //   const sql = Builder.hasTable(tableName)
+  //   const sql = Builder.hasTable(table)
   //   const result = await this.#c.query(sql)
   //   return result.length > 0
   // }
 
-  // static async hasColumn(tableName: string, columnName: string): Promise<boolean> {
+  // static async hasColumn(table: string, columnName: string): Promise<boolean> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
-  //   const sql = Builder.hasColumn(tableName, columnName)
+  //   const sql = Builder.hasColumn(table, columnName)
   //   const result = await this.#c.query(sql)
   //   return result.some((row: any) => row.name === columnName)
   // }
 
-  // static async hasColumns(tableName: string, ...columnNames: string[]): Promise<boolean> {
+  // static async hasColumns(table: string, ...columnNames: string[]): Promise<boolean> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
-  //   const sql = Builder.hasColumn(tableName, '')
+  //   const sql = Builder.hasColumn(table, '')
   //   const result = await this.#c.query(sql)
   //   const existingColumns = result.map((row: any) => row.name)
 
@@ -130,20 +142,20 @@ export class Schema {
   //   return result.map((row: any) => row.name)
   // }
 
-  // static async getColumns(tableName: string): Promise<any[]> {
+  // static async getColumns(table: string): Promise<any[]> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
-  //   const sql = Builder.getColumns(tableName)
+  //   const sql = Builder.getColumns(table)
   //   return await this.#c.query(sql)
   // }
 
-  // static async getColumnType(tableName: string, columnName: string): Promise<string | null> {
+  // static async getColumnType(table: string, columnName: string): Promise<string | null> {
   //   if (!this.#c) {
   //     throw new Error('Database connection not set')
   //   }
 
-  //   const sql = Builder.getColumns(tableName)
+  //   const sql = Builder.getColumns(table)
   //   const result = await this.#c.query(sql)
   //   const column = result.find((row: any) => row.name === columnName)
   //   return column ? column.type : null

package/src/migrations/types.ts

@@ -18,6 +18,7 @@ export interface ColumnDefinition {
   unsigned?: boolean,
   index?: boolean,
   comment?: string,
+  raw?: string,
 }
 
 export interface IndexDefinition {

package/src/utils.ts

@@ -132,3 +132,48 @@ export function isJoinCompare(val: any, schema?: DBSchema) {
   const keys = zGet(val, schema)
   return keys && keys?.length
 }
+
+const reservedWords = new Set([
+  'ABORT', 'ACTION', 'ADD', 'AFTER', 'ALL', 'ALTER', 'ANALYZE', 'AND', 'AS',
+  'ASC', 'ATTACH', 'AUTOINCREMENT', 'BEFORE', 'BEGIN', 'BETWEEN', 'BY',
+  'CASCADE', 'CASE', 'CAST', 'CHECK', 'COLLATE', 'COLUMN', 'COMMIT',
+  'CONFLICT', 'CONSTRAINT', 'CREATE', 'CROSS', 'CURRENT', 'CURRENT_DATE',
+  'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'DATABASE', 'DEFAULT', 'DEFERRABLE',
+  'DEFERRED', 'DELETE', 'DESC', 'DETACH', 'DISTINCT', 'DROP', 'EACH',
+  'ELSE', 'END', 'ESCAPE', 'EXCEPT', 'EXCLUSIVE', 'EXISTS', 'EXPLAIN',
+  'FAIL', 'FOR', 'FOREIGN', 'FROM', 'FULL', 'GLOB', 'GROUP', 'HAVING',
+  'IF', 'IGNORE', 'IMMEDIATE', 'IN', 'INDEX', 'INDEXED', 'INITIALLY',
+  'INNER', 'INSERT', 'INSTEAD', 'INTERSECT', 'INTO', 'IS', 'ISNULL',
+  'JOIN', 'KEY', 'LEFT', 'LIKE', 'LIMIT', 'MATCH', 'NATURAL', 'NO',
+  'NOT', 'NOTNULL', 'NULL', 'OF', 'OFFSET', 'ON', 'OR', 'ORDER',
+  'OUTER', 'PLAN', 'PRAGMA', 'PRIMARY', 'QUERY', 'RAISE', 'RECURSIVE',
+  'REFERENCES', 'REGEXP', 'REINDEX', 'RELEASE', 'RENAME', 'REPLACE',
+  'RESTRICT', 'RIGHT', 'ROLLBACK', 'ROW', 'SAVEPOINT', 'SELECT',
+  'SET', 'TABLE', 'TEMP', 'TEMPORARY', 'THEN', 'TO', 'TRANSACTION',
+  'TRIGGER', 'UNION', 'UNIQUE', 'UPDATE', 'USING', 'VACUUM', 'VALUES',
+  'VIEW', 'VIRTUAL', 'WHEN', 'WHERE', 'WITH', 'WITHOUT',
+])
+export function tableName(name: string) {
+  name = name.trim()
+  if (!name || name?.includes('.'))
+    throw new Error(`Invalid table name "${!name ? 'empty' : name}"`)
+
+  if (
+    /^[0-9]/.test(name)
+    || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)
+    || reservedWords.has(name.toUpperCase())
+  ) {
+    return `"${name}"`
+  }
+
+  return name
+}
+
+export function tableSlug(name: string) {
+  return name.trim()
+    .replace(/([A-Z])/g, '_$1')
+    .replace(/[^a-zA-Z0-9_]/g, '_')
+    .toLowerCase()
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+}