forj 0.1.3 → 0.1.5

package/package.json

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

package/src/migrations/blueprint.ts

@@ -1,7 +1,6 @@
 import pluralize from 'pluralize'
 import Column from './column'
 import ForeignKey from './foreign-key'
-import { tableName } from '../utils'
 import type {
   ColumnDefinition, IndexDefinition, ForeignKeyDefinition,
 } from './types'
@@ -15,7 +14,7 @@ export class Blueprint {
   #renameColumns: Map<string, string> = new Map()
 
   constructor(table: string) {
-    this.#table = tableName(table)
+    this.#table = table
   }
 
   #column(definition: ColumnDefinition) {

package/src/migrations/builder.ts

@@ -1,10 +1,10 @@
 import { Blueprint } from './blueprint'
-import { tableName, tableSlug } from '../utils'
+import { sqlName, tableSlug } from '../utils'
 import type { ColumnDefinition, IndexDefinition, ForeignKeyDefinition } from './types'
 
 export default class SchemaBuilder {
   static create(blueprint: Blueprint, exist: boolean = false): string {
-    const table = blueprint.table
+    const table = sqlName(blueprint.table)
     const columns = blueprint.columns
     const indexes = blueprint.indexes
     const foreignKeys = blueprint.foreignKeys
@@ -23,7 +23,7 @@ export default class SchemaBuilder {
   }
 
   static alter(blueprint: Blueprint): string[] {
-    const table = blueprint.table
+    const table = sqlName(blueprint.table)
     const statements: string[] = []
 
     const columns = blueprint.columns
@@ -31,10 +31,10 @@ export default class SchemaBuilder {
       columns.forEach(col => statements.push(`ALTER TABLE ${table} ADD COLUMN ${this.#column(col)};`))
 
     const dropColumns = blueprint.dropColumns
-    dropColumns.forEach(col => statements.push(`ALTER TABLE ${table} DROP COLUMN ${col};`))
+    dropColumns.forEach(col => statements.push(`ALTER TABLE ${table} DROP COLUMN ${sqlName(col)};`))
 
     const renameColumns = blueprint.renameColumns
-    renameColumns.forEach((newName, oldName) => statements.push(`ALTER TABLE ${table} RENAME COLUMN ${oldName} TO ${newName};`))
+    renameColumns.forEach((newName, oldName) => statements.push(`ALTER TABLE ${table} RENAME COLUMN ${sqlName(oldName)} TO ${sqlName(newName)};`))
 
     const indexes = blueprint.indexes
     indexes.forEach(idx => {
@@ -49,7 +49,7 @@ export default class SchemaBuilder {
   }
 
   static #column(column: ColumnDefinition) {
-    let sql = `${column.name} ${column.type}`
+    let sql = `${sqlName(column.name)} ${column.type}`
 
     if (column.length && !column.type.includes('('))
       sql += `(${column.length})`
@@ -99,8 +99,8 @@ export default class SchemaBuilder {
 
   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)
+    const columns = index.columns.map(column => sqlName(column)).join(', ')
+    table = sqlName(table)
 
     switch (index.type) {
       case 'primary':
@@ -116,8 +116,8 @@ export default class SchemaBuilder {
 
   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)
+    const columns = index.columns.map(column => sqlName(column)).join(', ')
+    table = sqlName(table)
 
     switch (index.type) {
       case 'primary':
@@ -132,7 +132,7 @@ export default class SchemaBuilder {
   }
 
   static #foreignKey(fk: ColumnDefinition | ForeignKeyDefinition, column: boolean = false): string {
-    let sql = (column ? '' : `FOREIGN KEY (${fk.name})`) +` REFERENCES ${fk.on}(${fk.references})`
+    let sql = (column ? '' : `FOREIGN KEY (${sqlName(fk.name)})`) +` REFERENCES ${sqlName(fk.on)}(${sqlName(fk.references)})`
 
     if (fk.onDelete)
       sql += ` ON DELETE ${fk.onDelete.toUpperCase()}`
@@ -144,7 +144,7 @@ export default class SchemaBuilder {
   }
 
   static drop(table: string, exist: boolean = false) {
-    return `DROP TABLE ${exist ? 'IF EXISTS ' : ''}${tableName(table)};`
+    return `DROP TABLE ${exist ? 'IF EXISTS ' : ''}${sqlName(table)};`
   }
 
   static dropIfExists(table: string) {
@@ -152,7 +152,7 @@ export default class SchemaBuilder {
   }
 
   static dropView(view: string, exist: boolean = false) {
-    return `DROP VIEW ${exist ? 'IF EXISTS ' : ''}[${tableName(view)}];`
+    return `DROP VIEW ${exist ? 'IF EXISTS ' : ''}[${sqlName(view)}];`
   }
 
   static dropViewIfExists(view: string) {
@@ -160,15 +160,15 @@ export default class SchemaBuilder {
   }
 
   static rename(from: string, to: string) {
-    return `ALTER TABLE ${tableName(from)} RENAME TO ${tableName(to)};`
+    return `ALTER TABLE ${sqlName(from)} RENAME TO ${sqlName(to)};`
   }
 
   static hasTable(table: string) {
-    return `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName(table)}';`
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name='${sqlName(table)}';`
   }
 
   static hasColumn(table: string, columnName: string) { // TODO refactor..
-    return `PRAGMA table_info(${tableName(table)});`
+    return `PRAGMA table_info(${sqlName(table)});`
   }
 
   static getAllTables() {
@@ -176,10 +176,10 @@ export default class SchemaBuilder {
   }
 
   static getColumns(table: string): string {
-    return `PRAGMA table_info(${tableName(table)});`
+    return `PRAGMA table_info(${sqlName(table)});`
   }
 
   static dropAllTables(tables: string[]) {
-    return tables.map(table => `DROP TABLE IF EXISTS ${tableName(table)};`)
+    return tables.map(table => `DROP TABLE IF EXISTS ${sqlName(table)};`)
   }
 }

package/src/migrations/schema.ts

@@ -31,7 +31,7 @@ export class Schema {
   }
 
   // mudei tudo this.#executeSql -> this.#addStatement
-  // static async #executeSql(...sql: string[] | string[][]): Promise<void> {
+  // static #executeSql(...sql: string[] | string[][]) {
   //   sql = sql.flat(Infinity) as string[]
   //   // if (this.#c) {
   //   //   for (const statement of sql) {
@@ -41,50 +41,66 @@ export class Schema {
   //   this.#addStatement(...sql)
   // }
 
-  static async create(table: string, fn: BlueprintFn, exist: boolean = false): Promise<void> {
+  static #blueprint(table: string, ...fns: BlueprintFn[]) {
     const blueprint = new Blueprint(table)
-    fn(blueprint)
-    await this.#addStatement(Builder.create(blueprint, exist))
+    fns.flatMap(fn => fn && fn(blueprint))
+    return blueprint
   }
 
-  static async createIfNotExists(table: string, fn: BlueprintFn): Promise<void> {
+  static create(table: string, fn: BlueprintFn, exist: boolean = false) {
+    this.#addStatement(Builder.create(this.#blueprint(table, fn), exist))
+  }
+
+  static createIfNotExists(table: string, fn: BlueprintFn) {
     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 createPivot(table: string, fn: BlueprintFn): void
+  static createPivot(table: string, columns: string[]): void
+  static createPivot(table: string, columns: string[], fn: BlueprintFn): void
+  static createPivot(table: string, columns: string[] | BlueprintFn, fn?: BlueprintFn) {
+    const hasColumn = Array.isArray(columns)
+    columns = hasColumn ? columns as string[] : [] // @ts-ignore
+    fn = hasColumn ? fn : columns
+
+    this.#addStatement(Builder.create(this.#blueprint(table, fn as BlueprintFn, (table: Blueprint) => {
+      columns.forEach(column => table.foreignId(column))
+      table.primary(table.columns.map(c => c.name))
+    })).slice(0, -1) + ' WITHOUT ROWID;')
+  }
+
+  static table(table: string, fn: BlueprintFn) {
+    this.#addStatement(Builder.alter(this.#blueprint(table, fn)))
   }
 
-  static async drop(table: string): Promise<void> {
-    await this.#addStatement(Builder.drop(table))
+  static drop(table: string) {
+    this.#addStatement(Builder.drop(table))
   }
 
-  static async dropIfExists(table: string): Promise<void> {
-    await this.#addStatement(Builder.dropIfExists(table))
+  static dropIfExists(table: string) {
+    this.#addStatement(Builder.dropIfExists(table))
   }
 
-  static async rename(from: string, to: string): Promise<void> {
-    await this.#addStatement(Builder.rename(from, to))
+  static rename(from: string, to: string) {
+    this.#addStatement(Builder.rename(from, to))
   }
 
-  static async dropView(view: string): Promise<void> {
-    await this.#addStatement(Builder.dropView(view))
+  static dropView(view: string) {
+    this.#addStatement(Builder.dropView(view))
   }
 
-  static async dropViewIfExists(view: string): Promise<void> {
-    await this.#addStatement(Builder.dropViewIfExists(view))
+  static dropViewIfExists(view: string) {
+    this.#addStatement(Builder.dropViewIfExists(view))
   }
 
-  static async disableForeignKeyConstraints(): Promise<void> {
+  static disableForeignKeyConstraints() {
     this.#foreignKeyConstraintsEnabled = false
-    await this.#addStatement('PRAGMA foreign_keys = OFF;')
+    this.#addStatement('PRAGMA foreign_keys = OFF;')
   }
 
-  static async enableForeignKeyConstraints(): Promise<void> {
+  static enableForeignKeyConstraints() {
     this.#foreignKeyConstraintsEnabled = true
-    await this.#addStatement('PRAGMA foreign_keys = ON;')
+    this.#addStatement('PRAGMA foreign_keys = ON;')
   }
 
   static isForeignKeyConstraintsEnabled(): boolean {
@@ -98,13 +114,13 @@ export class Schema {
     return this.sql
   }
 
-  // static async dropAllTables(): Promise<void> {
+  // static dropAllTables() {
   //   const tables = await this.getAllTables()
   //   const sql = Builder.dropAllTables(tables)
-  //   await this.#addStatement(sql)
+  //   this.#addStatement(sql)
   // }
 
-  // static async hasTable(table: string): Promise<boolean> {
+  // static hasTable(table: string): Promise<boolean> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
@@ -113,7 +129,7 @@ export class Schema {
   //   return result.length > 0
   // }
 
-  // static async hasColumn(table: string, columnName: string): Promise<boolean> {
+  // static hasColumn(table: string, columnName: string): Promise<boolean> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
@@ -122,7 +138,7 @@ export class Schema {
   //   return result.some((row: any) => row.name === columnName)
   // }
 
-  // static async hasColumns(table: string, ...columnNames: string[]): Promise<boolean> {
+  // static hasColumns(table: string, ...columnNames: string[]): Promise<boolean> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
@@ -133,7 +149,7 @@ export class Schema {
   //   return columnNames.every(col => existingColumns.includes(col))
   // }
 
-  // static async getAllTables(): Promise<string[]> {
+  // static getAllTables(): Promise<string[]> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
@@ -142,7 +158,7 @@ export class Schema {
   //   return result.map((row: any) => row.name)
   // }
 
-  // static async getColumns(table: string): Promise<any[]> {
+  // static getColumns(table: string): Promise<any[]> {
   //   if (!this.#c)
   //     throw new Error('Database connection not set')
 
@@ -150,7 +166,7 @@ export class Schema {
   //   return await this.#c.query(sql)
   // }
 
-  // static async getColumnType(table: string, columnName: string): Promise<string | null> {
+  // static getColumnType(table: string, columnName: string): Promise<string | null> {
   //   if (!this.#c) {
   //     throw new Error('Database connection not set')
   //   }

package/src/utils.ts

@@ -153,7 +153,7 @@ export const SQLITE_KEYWORDS = new Set([
   'WHERE', 'WINDOW', 'WITH', 'WITHOUT',
 ])
 
-export function tableName(name: string) {
+export function sqlName(name?: string) {
 	return !name
 		|| !name.match(/^[a-zA-Z_]/)
 		|| name.match(/\W/)