forj 0.1.2 → 0.1.4

package/package.json

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

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,65 @@ 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[], 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 +113,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 +128,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 +137,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 +148,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 +157,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 +165,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

@@ -132,41 +132,34 @@ 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',
+// List taken from `aKeywordTable` in https://github.com/sqlite/sqlite/blob/378bf82e2bc09734b8c5869f9b148efe37d29527/tool/mkkeywordhash.c#L172
+// prettier-ignore
+export const SQLITE_KEYWORDS = new Set([
+  'ABORT', 'ACTION', 'ADD', 'AFTER', 'ALL', 'ALTER', 'ALWAYS', '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', 'DEFERRED',
+  'DEFERRABLE', 'DELETE', 'DESC', 'DETACH', 'DISTINCT', 'DO', 'DROP', 'END', 'EACH', 'ELSE',
+  'ESCAPE', 'EXCEPT', 'EXCLUSIVE', 'EXCLUDE', 'EXISTS', 'EXPLAIN', 'FAIL', 'FILTER', 'FIRST',
+  'FOLLOWING', 'FOR', 'FOREIGN', 'FROM', 'FULL', 'GENERATED', 'GLOB', 'GROUP', 'GROUPS', 'HAVING',
+  'IF', 'IGNORE', 'IMMEDIATE', 'IN', 'INDEX', 'INDEXED', 'INITIALLY', 'INNER', 'INSERT', 'INSTEAD',
+  'INTERSECT', 'INTO', 'IS', 'ISNULL', 'JOIN', 'KEY', 'LAST', 'LEFT', 'LIKE', 'LIMIT', 'MATCH',
+  'MATERIALIZED', 'NATURAL', 'NO', 'NOT', 'NOTHING', 'NOTNULL', 'NULL', 'NULLS', 'OF', 'OFFSET',
+  'ON', 'OR', 'ORDER', 'OTHERS', 'OUTER', 'OVER', 'PARTITION', 'PLAN', 'PRAGMA', 'PRECEDING',
+  'PRIMARY', 'QUERY', 'RAISE', 'RANGE', 'RECURSIVE', 'REFERENCES', 'REGEXP', 'REINDEX', 'RELEASE',
+  'RENAME', 'REPLACE', 'RESTRICT', 'RETURNING', 'RIGHT', 'ROLLBACK', 'ROW', 'ROWS', 'SAVEPOINT',
+  'SELECT', 'SET', 'TABLE', 'TEMP', 'TEMPORARY', 'THEN', 'TIES', 'TO', 'TRANSACTION', 'TRIGGER',
+  'UNBOUNDED', 'UNION', 'UNIQUE', 'UPDATE', 'USING', 'VACUUM', 'VALUES', 'VIEW', 'VIRTUAL', 'WHEN',
+  'WHERE', 'WINDOW', '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 tableName(name: string) {
+	return !name
+		|| !name.match(/^[a-zA-Z_]/)
+		|| name.match(/\W/)
+		|| SQLITE_KEYWORDS.has(name.toUpperCase())
+		? `"${name}"`
+		: name
 }
 
 export function tableSlug(name: string) {