forj 0.0.5 → 0.0.7

package/package.json

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

package/src/migrations/blueprint.ts

@@ -23,7 +23,7 @@ export class Blueprint {
   }
 
   id(name: string = 'id') { // Auto-increment ID (bigint unsigned)
-    return this.#column({ name, type: 'BIGINT', unsigned: true, autoIncrement: true, primary: true, nullable: false })
+    return this.#column({ name, type: 'INTEGER', autoIncrement: true, primary: true, nullable: false })
   }
 
   string(name: string, length: number = 255) {
@@ -34,49 +34,58 @@ export class Blueprint {
     return this.#column({ name, type: 'TEXT', nullable: false })
   }
 
-  integer(name: string) {
+  int(name: string) {
     return this.#column({ name, type: 'INTEGER', nullable: false })
   }
-
-  bigInteger(name: string) {
-    return this.#column({ name, type: 'BIGINT', nullable: false })
+  integer(name: string) {
+    return this.int(name)
   }
-
-  tinyInteger(name: string) {
-    return this.#column({ name, type: 'TINYINT', nullable: false })
+  real(name: string) {
+    return this.#column({ name, type: 'REAL', nullable: false })
+  }
+  numeric(name: string) {
+    return this.#column({ name, type: 'NUMERIC', nullable: false })
   }
 
+  // bigInteger(name: string) {
+  //   return this.#column({ name, type: 'BIGINT', nullable: false })
+  // }
+
+  // tinyInteger(name: string) {
+  //   return this.#column({ name, type: 'TINYINT', nullable: false })
+  // }
+
   boolean(name: string) {
-    return this.#column({ name, type: 'BOOLEAN', nullable: false })
+    return this.#column({ name, type: 'INTEGER', nullable: false })
   }
 
-  decimal(name: string, precision: number = 8, scale: number = 2) {
-    return this.#column({ name, type: `DECIMAL(${precision},${scale})`, nullable: false })
-  }
+  // decimal(name: string, precision: number = 8, scale: number = 2) {
+  //   return this.#column({ name, type: `DECIMAL(${precision},${scale})`, nullable: false })
+  // }
 
-  float(name: string) {
-    return this.#column({ name, type: 'FLOAT', nullable: false })
-  }
+  // float(name: string) {
+  //   return this.#column({ name, type: 'FLOAT', nullable: false })
+  // }
 
-  double(name: string) {
-    return this.#column({ name, type: 'DOUBLE', nullable: false })
-  }
+  // double(name: string) {
+  //   return this.#column({ name, type: 'DOUBLE', nullable: false })
+  // }
 
-  date(name: string) {
-    return this.#column({ name, type: 'DATE', nullable: false })
-  }
+  // date(name: string) {
+  //   return this.#column({ name, type: 'DATE', nullable: false })
+  // }
 
-  dateTime(name: string) {
-    return this.#column({ name, type: 'DATETIME', nullable: false })
-  }
+  // dateTime(name: string) {
+  //   return this.#column({ name, type: 'DATETIME', nullable: false })
+  // }
 
-  timestamp(name: string) {
-    return this.#column({ name, type: 'TIMESTAMP', nullable: false })
-  }
+  // timestamp(name: string) {
+  //   return this.#column({ name, type: 'TIMESTAMP', nullable: false })
+  // }
 
-  time(name: string) {
-    return this.#column({ name, type: 'TIME', nullable: false })
-  }
+  // time(name: string) {
+  //   return this.#column({ name, type: 'TIME', nullable: false })
+  // }
 
   json(name: string) {
     return this.#column({ name, type: 'JSON', nullable: false })
@@ -86,14 +95,18 @@ export class Blueprint {
     return this.#column({ name, type: `ENUM(${values.map(v => `'${v}'`).join(', ')})`, nullable: false })
   }
 
+  blob(name: string) {
+    return this.#column({ name, type: 'BLOB', nullable: false })
+  }
+
   timestamps() {
-    this.timestamp('created_at')
-    this.timestamp('updated_at')
+    this.#column({ name: 'created_at', type: 'TEXT', nullable: false })
+    this.#column({ name: 'updated_at', type: 'TEXT', nullable: false })
     return this
   }
 
   softDelete(name: string = 'deleted_at') {
-    this.timestamp(name).nullable()
+    this.#column({ name, type: 'TEXT', nullable: true })
     return this
   }
 

package/src/migrations/builder.ts

@@ -53,8 +53,11 @@ export default class SchemaBuilder {
     if (column.length && !column.type.includes('('))
       sql += `(${column.length})`
 
-    if (column.unsigned)
-      sql += ' UNSIGNED'
+    if (column.autoIncrement)
+      sql += ' AUTOINCREMENT'
+
+    // if (column.unsigned)
+    //   sql += ' UNSIGNED'
 
     if (column.nullable) {
       sql += ' NULL'
@@ -62,9 +65,6 @@ export default class SchemaBuilder {
       sql += ' NOT NULL'
     }
 
-    if (column.autoIncrement)
-      sql += ' AUTO_INCREMENT'
-
     if (column.default !== undefined) {
       if (column.default === null) {
         sql += ' DEFAULT NULL'
@@ -83,8 +83,8 @@ export default class SchemaBuilder {
     if (column.primary)
       sql += ' PRIMARY KEY'
 
-    if (column.comment)
-      sql += ` COMMENT '${column.comment.replace(/'/g, "''")}'`
+    // if (column.comment)
+    //   sql += ` COMMENT '${column.comment.replace(/'/g, "''")}'`
 
     return sql
   }

package/src/migrations/index.ts

@@ -1,5 +1,4 @@
 export { Migration } from './migration'
 export { Migrator } from './migrator'
-
 export { Schema } from './schema'
 export { Blueprint } from './blueprint'

package/src/migrations/migrator.ts

@@ -3,44 +3,45 @@ import { mkdirSync, existsSync, writeFileSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import { Datte, IMPORT } from 't0n'
 import { Schema } from './schema'
-import { MigrationInfo, MigrationClass } from './types'
+import { MigrationInfo, MigrationClass, Queue } from './types'
 
 const __root = resolve(dirname(new URL(import.meta.url).pathname), '../../../..')
 
 export class Migrator {
-  static #dir: string = ''
-  static #folder: string = 'migrations'
-  static #sqlFolder: string = 'sql'
+  static #input: string = join(__root, 'migrations')
+  static #output: string = join(__root, 'migrations', 'sql')
 
-  static dir(dir: string) {
-    this.#dir = dir
+  static inputDir(dir: string) {
+    this.#input = join(__root, dir)
     return this
   }
-
-  static folder(dir: string) {
-    this.#dir = dir
+  static outputDir(dir: string) {
+    this.#output = join(__root, dir)
     return this
   }
 
-  static async toSql(outputDir: string = '') {
-    const dir = this.#dir || join(__root, this.#folder)
-    outputDir ||= join(dir, this.#sqlFolder)
-
-    this.#ensureDir(dir)
-    this.#ensureDir(outputDir)
-    const files = (await glob(join(dir, '/*.{ts,js}'))).filter(file => !file.includes('.d.')) // TODO: sort
+  static async queue() {
+    this.#ensureDir(this.#input)
+    const files = await glob(join(this.#input, '/*.{ts,js}'))
+    const list: Queue = {'pending': [], 'migrated': []}
 
     for (const file of files) {
+      if (file.includes('.d.')) continue
       const info = await this.#info(file)
-      if (!info)
-        continue // TODO: trigger a warn
+      if (!info) continue // TODO: trigger a warn
 
-      const sql = await this.run(info.handler)
-      const path = join(outputDir, info.name +'.sql')
-      if (!existsSync(path))
-        writeFileSync(path, `-- Migration: ${info.name}\n\n${sql}\n`)
+      list[info.migrated ? 'migrated' : 'pending'].push(info)
     }
 
+    return list
+  }
+
+  static async compile(migrations: MigrationInfo[]) {
+    for (const migration of migrations) {
+      const sql = await this.run(migration.handler)
+      if (!existsSync(migration.output))
+        writeFileSync(migration.output, `-- Migration: ${migration.name}\n\n${sql}\n`)
+    }
   }
 
   static async run(handler: MigrationClass) {
@@ -62,13 +63,16 @@ export class Migrator {
   }
 
   static async #info(fileName: string): Promise<MigrationInfo | null> {
-    const name = fileName.replace(/\.[jt]s$/, '')
+    let name = fileName.replace(/\.[jt]s$/, '')
     const match = name.match(/\/(\d{4})_(\d{2})_(\d{2})_(\d{2})(\d{2})(\d{2})_(.+)$/)
+    name = name.split('/').at(-1) as string
 
     if (!match) return null
     const [, year, month, day, hour, minute, second, slugName] = match
 
-    const mod = await IMPORT(join(__root, fileName))
+    const input = join(__root, fileName)
+    const output = join(this.#output, name +'.sql')
+    const mod = await IMPORT(input)
     const handler = mod.default as MigrationClass
 
     return {
@@ -80,28 +84,36 @@ export class Migrator {
         parseInt(minute),
         parseInt(second)
       ).getTime(),
-      name: name.split('/').at(-1) as string,
-      fileName,
-      className: this.#toClassName(slugName),
+      name,
+      className: this.className(slugName),
       handler,
+      input,
+      output,
+      migrated: existsSync(output)
     }
   }
 
-  static #toClassName(name: string) {
-    return name
+  static className(name: string) {
+    const lastSlashIndex = name.lastIndexOf('/')
+    const fileName = lastSlashIndex >= 0 ? name.substring(lastSlashIndex + 1) : name
+
+    const dotIndex = fileName.lastIndexOf('.')
+    const baseName = dotIndex > 0 ? fileName.substring(0, dotIndex) : fileName
+
+    return baseName
       .split(/[-_.]/)
       .map(s => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())
       .join('')
+      + Datte.dateTime().replace(/[:.\-\s_]/g, '')
   }
 
   static fileName(name: string) {
     return (
-      name.replace(/([A-Z])/g, '_$1') // snake_case
+      Datte.dateTime().replace(/[.-\s]/g, '_').replace(/\:/g, '')
+      +'_'+ name.replace(/([A-Z])/g, '_$1') // snake_case
           .replace(/\s+/g, '_')
           .toLowerCase()
-      + '_'
-      + Datte.dateTime().replace(/[:.-]/g, '_').replace(/_+/g, '_')
-    ).replace(/^_+|_+$/g, '')
+    ).replace(/_+/g, '_')
   }
 
   static #ensureDir(dir: string) {

package/src/migrations/types.ts

@@ -1,5 +1,5 @@
 import { Blueprint } from './blueprint'
-import { Migration } from './migration'
+// import { Migration } from './migration'
 
 export type BlueprintFn = (table: Blueprint) => void
 
@@ -34,12 +34,17 @@ export interface ForeignKeyDefinition {
   onUpdate?: 'cascade' | 'set null' | 'restrict' | 'no action',
 }
 
+export type QueueType = 'pending' | 'migrated'
+export type Queue = Record<QueueType, MigrationInfo[]>
+
 export interface MigrationInfo {
   timestamp: number,
   name: string,
-  fileName: string,
   className: string,
   handler: MigrationClass,
+  input: string,
+  output: string,
+  migrated: boolean,
 }
 
 export interface MigrationRecord {