forj 0.0.3 → 0.0.5

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "forj",
   "description": "SQLite ORM and Query Builder whitout dependencies",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "main": "src/index.ts",
   "files": ["src"],
   "exports": {
     ".": "./src/index.ts",
     "./d1": "./src/d1/index.ts",
-    "./d1/types": "./src/d1/types.ts"
+    "./d1/types": "./src/d1/types.ts",
+    "./dynamodb": "./src/dynamodb/index.ts",
+    "./dynamodb/types": "./src/dynamodb/types.ts",
+    "./migrate": "./src/migrations/index.ts"
   },
   "-exports": {
     ".": {
@@ -59,6 +62,8 @@
     "resources",
     "support",
     "sqlite",
+    "migration",
+    "schema",
     "orm",
     "query",
     "builder",
@@ -71,9 +76,15 @@
     "postgres",
     "postgresql",
     "typescript",
+    "serverless",
+    "dynamo",
+    "dynamodb",
     "aws",
     "lambda",
     "llrt",
+    "d1",
+    "cloudflare",
+    "workers",
     "deno",
     "bun",
     "nodejs"

package/src/index.ts

@@ -1 +1,2 @@
+export { Migrator, Migration, Schema, Blueprint } from './migrations'
 export { default as QueryBuilder } from './query-builder'

package/src/migrations/blueprint.ts

@@ -0,0 +1,170 @@
+import Column from './column'
+import ForeignKey from './foreign-key'
+import type {
+  ColumnDefinition, IndexDefinition, ForeignKeyDefinition,
+} from './types'
+
+export class Blueprint {
+  #table: string
+  #columns: ColumnDefinition[] = []
+  #indexes: IndexDefinition[] = []
+  #foreignKeys: ForeignKeyDefinition[] = []
+  #dropColumns: string[] = []
+  #renameColumns: Map<string, string> = new Map()
+
+  constructor(table: string) {
+    this.#table = table
+  }
+
+  #column(definition: ColumnDefinition) {
+    const column: ColumnDefinition = definition
+    this.#columns.push(column)
+    return new Column(column)
+  }
+
+  id(name: string = 'id') { // Auto-increment ID (bigint unsigned)
+    return this.#column({ name, type: 'BIGINT', unsigned: true, autoIncrement: true, primary: true, nullable: false })
+  }
+
+  string(name: string, length: number = 255) {
+    return this.#column({ name, type: 'VARCHAR', length, nullable: false })
+  }
+
+  text(name: string) {
+    return this.#column({ name, type: 'TEXT', nullable: false })
+  }
+
+  integer(name: string) {
+    return this.#column({ name, type: 'INTEGER', 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 })
+  }
+
+  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 })
+  }
+
+  double(name: string) {
+    return this.#column({ name, type: 'DOUBLE', nullable: false })
+  }
+
+  date(name: string) {
+    return this.#column({ name, type: 'DATE', nullable: false })
+  }
+
+  dateTime(name: string) {
+    return this.#column({ name, type: 'DATETIME', nullable: false })
+  }
+
+  timestamp(name: string) {
+    return this.#column({ name, type: 'TIMESTAMP', nullable: false })
+  }
+
+  time(name: string) {
+    return this.#column({ name, type: 'TIME', nullable: false })
+  }
+
+  json(name: string) {
+    return this.#column({ name, type: 'JSON', nullable: false })
+  }
+
+  enum(name: string, values: string[]) {
+    return this.#column({ name, type: `ENUM(${values.map(v => `'${v}'`).join(', ')})`, nullable: false })
+  }
+
+  timestamps() {
+    this.timestamp('created_at')
+    this.timestamp('updated_at')
+    return this
+  }
+
+  softDelete(name: string = 'deleted_at') {
+    this.timestamp(name).nullable()
+    return this
+  }
+
+  softDeletes(name: string = 'deleted_at') {
+    return this.softDelete(name)
+  }
+
+  foreign(column: string) {
+    const fk: ForeignKeyDefinition = { column, references: '', on: '' }
+    this.#foreignKeys.push(fk)
+    return new ForeignKey(fk)
+  }
+
+  index(columns: string | string[], name?: string): this {
+    this.#indexes.push({
+      columns: Array.isArray(columns) ? columns : [columns],
+      type: 'index',
+      name
+    })
+    return this
+  }
+
+  unique(columns: string | string[], name?: string): this {
+    this.#indexes.push({
+      columns: Array.isArray(columns) ? columns : [columns],
+      type: 'unique',
+      name
+    })
+    return this
+  }
+
+  primary(columns: string | string[], name?: string): this {
+    this.#indexes.push({
+      columns: Array.isArray(columns) ? columns : [columns],
+      type: 'primary',
+      name
+    })
+    return this
+  }
+
+  dropColumn(...name: string[] | string[][]): this {
+    this.#dropColumns.push(...name.flat(Infinity) as string[])
+    return this
+  }
+
+  renameColumn(from: string, to: string): this {
+    this.#renameColumns.set(from, to)
+    return this
+  }
+
+  get table(): string {
+    return this.#table
+  }
+
+  get columns() {
+    return this.#columns
+  }
+
+  get indexes() {
+    return this.#indexes
+  }
+
+  get foreignKeys() {
+    return this.#foreignKeys
+  }
+
+  get dropColumns() {
+    return this.#dropColumns
+  }
+
+  get renameColumns() {
+    return this.#renameColumns
+  }
+}

package/src/migrations/builder.ts

@@ -0,0 +1,167 @@
+import { Blueprint } from './blueprint'
+import type { ColumnDefinition, IndexDefinition, ForeignKeyDefinition } from './types'
+
+export default class SchemaBuilder {
+  static create(blueprint: Blueprint): string {
+    const tableName = 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 foreignKeyDefinitions = foreignKeys.map(fk => this.#foreignKey(fk))
+
+    const allDefinitions = [
+      ...columnDefinitions,
+      ...indexDefinitions,
+      ...foreignKeyDefinitions
+    ].filter(Boolean)
+
+    return `CREATE TABLE ${tableName} (\n  ${allDefinitions.join(',\n  ')}\n);`
+  }
+
+  static alter(blueprint: Blueprint): string[] {
+    const tableName = 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)};`))
+
+    const dropColumns = blueprint.dropColumns
+    dropColumns.forEach(col => statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${col};`))
+
+    const renameColumns = blueprint.renameColumns
+    renameColumns.forEach((newName, oldName) => statements.push(`ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`))
+
+    const indexes = blueprint.indexes
+    indexes.forEach(idx => {
+      const indexSql = this.#indexStatement(idx, tableName)
+      if (indexSql) statements.push(indexSql)
+    })
+
+    const foreignKeys = blueprint.foreignKeys
+    foreignKeys.forEach(fk => statements.push(`ALTER TABLE ${tableName} ADD ${this.#foreignKey(fk)};`))
+
+    return statements
+  }
+
+  static #column(column: ColumnDefinition) {
+    let sql = `${column.name} ${column.type}`
+
+    if (column.length && !column.type.includes('('))
+      sql += `(${column.length})`
+
+    if (column.unsigned)
+      sql += ' UNSIGNED'
+
+    if (column.nullable) {
+      sql += ' NULL'
+    } else {
+      sql += ' NOT NULL'
+    }
+
+    if (column.autoIncrement)
+      sql += ' AUTO_INCREMENT'
+
+    if (column.default !== undefined) {
+      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}`
+      } else {
+        sql += ` DEFAULT ${column.default}`
+      }
+    }
+
+    if (column.unique)
+      sql += ' UNIQUE'
+
+    if (column.primary)
+      sql += ' PRIMARY KEY'
+
+    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}`
+    const columns = index.columns.join(', ')
+
+    switch (index.type) {
+      case 'primary':
+        return `PRIMARY KEY (${columns})`
+      case 'unique':
+        return `UNIQUE KEY ${indexName} (${columns})`
+      case 'index':
+        return `KEY ${indexName} (${columns})`
+      default:
+        return ''
+    }
+  }
+
+  static #indexStatement(index: IndexDefinition, tableName: string): string {
+    const indexName = index.name || `${tableName}_${index.columns.join('_')}_${index.type}`
+    const columns = index.columns.join(', ')
+
+    switch (index.type) {
+      case 'primary':
+        return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columns});`
+      case 'unique':
+        return `CREATE UNIQUE INDEX ${indexName} ON ${tableName} (${columns});`
+      case 'index':
+        return `CREATE INDEX ${indexName} ON ${tableName} (${columns});`
+      default:
+        return ''
+    }
+  }
+
+  static #foreignKey(fk: ForeignKeyDefinition): string {
+    let sql = `FOREIGN KEY (${fk.column}) REFERENCES ${fk.on}(${fk.references})`
+
+    if (fk.onDelete)
+      sql += ` ON DELETE ${fk.onDelete.toUpperCase()}`
+
+    if (fk.onUpdate)
+      sql += ` ON UPDATE ${fk.onUpdate.toUpperCase()}`
+
+    return sql
+  }
+
+  static drop(tableName: string) {
+    return `DROP TABLE ${tableName};`
+  }
+
+  static dropIfExists(tableName: string) {
+    return `DROP TABLE IF EXISTS ${tableName};`
+  }
+
+  static rename(from: string, to: string) {
+    return `ALTER TABLE ${from} RENAME TO ${to};`
+  }
+
+  static hasTable(tableName: string) {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`
+  }
+
+  static hasColumn(tableName: string, columnName: string) { // TODO refactor..
+    return `PRAGMA table_info(${tableName});`
+  }
+
+  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 dropAllTables(tables: string[]) {
+    return tables.map(table => `DROP TABLE IF EXISTS ${table};`)
+  }
+}

package/src/migrations/column.ts

@@ -0,0 +1,45 @@
+import { ColumnDefinition } from './types'
+
+export default class Column {
+  constructor(private column: ColumnDefinition) {}
+
+  nullable() {
+    this.column.nullable = true
+    return this
+  }
+
+  unique() {
+    this.column.unique = true
+    return this
+  }
+
+  default(value: any) {
+    this.column.default = value
+    return this
+  }
+
+  unsigned() {
+    this.column.unsigned = true
+    return this
+  }
+
+  index() {
+    this.column.index = true
+    return this
+  }
+
+  comment(text: string) {
+    this.column.comment = text
+    return this
+  }
+
+  primary() {
+    this.column.primary = true
+    return this
+  }
+
+  autoIncrement() {
+    this.column.autoIncrement = true
+    return this
+  }
+}

package/src/migrations/foreign-key.ts

@@ -0,0 +1,25 @@
+import type { ForeignKeyDefinition } from './types'
+
+export default class ForeignKey {
+  constructor(private fk: ForeignKeyDefinition) {}
+
+  references(column: string) {
+    this.fk.references = column
+    return this
+  }
+
+  on(table: string) {
+    this.fk.on = table
+    return this
+  }
+
+  onDelete(action: 'cascade' | 'set null' | 'restrict' | 'no action') {
+    this.fk.onDelete = action;
+    return this;
+  }
+
+  onUpdate(action: 'cascade' | 'set null' | 'restrict' | 'no action') {
+    this.fk.onUpdate = action
+    return this
+  }
+}

package/src/migrations/index.ts

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

package/src/migrations/migration.ts

@@ -0,0 +1,5 @@
+export abstract class Migration {
+  static async run(): Promise<void> {
+    throw new Error('Method run() must be implemented in migration class')
+  }
+}

package/src/migrations/migrator.ts

@@ -0,0 +1,110 @@
+import glob from 'tiny-glob'
+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'
+
+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 dir(dir: string) {
+    this.#dir = dir
+    return this
+  }
+
+  static folder(dir: string) {
+    this.#dir = 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
+
+    for (const file of files) {
+      const info = await this.#info(file)
+      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`)
+    }
+
+  }
+
+  static async run(handler: MigrationClass) {
+    //  try {
+    //     await migrationClass.up()
+    //   } catch (error) {
+    //     // Try run() if up() is not implemented
+    //     if (migrationClass.run) {
+    //       await migrationClass.run()
+    //     } else {
+    //       throw error
+    //     }
+    //  }
+
+    if (!handler?.run) return ''
+    Schema.clearStatements()
+    await handler.run()
+    return Schema.sql
+  }
+
+  static async #info(fileName: string): Promise<MigrationInfo | null> {
+    const name = fileName.replace(/\.[jt]s$/, '')
+    const match = name.match(/\/(\d{4})_(\d{2})_(\d{2})_(\d{2})(\d{2})(\d{2})_(.+)$/)
+
+    if (!match) return null
+    const [, year, month, day, hour, minute, second, slugName] = match
+
+    const mod = await IMPORT(join(__root, fileName))
+    const handler = mod.default as MigrationClass
+
+    return {
+      timestamp: new Date(
+        parseInt(year),
+        parseInt(month) - 1, // Js months are 0-indexed
+        parseInt(day),
+        parseInt(hour),
+        parseInt(minute),
+        parseInt(second)
+      ).getTime(),
+      name: name.split('/').at(-1) as string,
+      fileName,
+      className: this.#toClassName(slugName),
+      handler,
+    }
+  }
+
+  static #toClassName(name: string) {
+    return name
+      .split(/[-_.]/)
+      .map(s => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())
+      .join('')
+  }
+
+  static fileName(name: string) {
+    return (
+      name.replace(/([A-Z])/g, '_$1') // snake_case
+          .replace(/\s+/g, '_')
+          .toLowerCase()
+      + '_'
+      + Datte.dateTime().replace(/[:.-]/g, '_').replace(/_+/g, '_')
+    ).replace(/^_+|_+$/g, '')
+  }
+
+  static #ensureDir(dir: string) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  }
+}

package/src/migrations/schema.ts

@@ -0,0 +1,151 @@
+
+import { Blueprint } from './blueprint'
+import Builder from './builder'
+
+import type {
+  BlueprintFn,
+  // SchemaConnection,
+} from './types'
+
+export class Schema {
+  // static #c: SchemaConnection | null = null
+  static #statements: string[] = []
+  static #foreignKeyConstraintsEnabled = true
+
+  // static setConnection(connection: SchemaConnection) {
+  //   this.#c = connection
+  //   return this
+  // }
+
+  static get statements() {
+    return this.#statements
+  }
+
+  static clearStatements() {
+    this.#statements = []
+    return this
+  }
+
+  static #addStatement(...sql: string[] | string[][]) {
+    this.#statements.push(...sql.flat(Infinity) as string[])
+  }
+
+  // mudei tudo this.#executeSql -> this.#addStatement
+  // static async #executeSql(...sql: string[] | string[][]): Promise<void> {
+  //   sql = sql.flat(Infinity) as string[]
+  //   // if (this.#c) {
+  //   //   for (const statement of sql) {
+  //   //     await this.#c.execute(statement)
+  //   //   }
+  //   // }
+  //   this.#addStatement(...sql)
+  // }
+
+  static async create(tableName: string, fn: BlueprintFn): Promise<void> {
+    const blueprint = new Blueprint(tableName)
+    fn(blueprint)
+    await this.#addStatement(Builder.create(blueprint))
+  }
+
+  static async table(tableName: string, fn: BlueprintFn): Promise<void> {
+    const blueprint = new Blueprint(tableName)
+    fn(blueprint)
+    await this.#addStatement(Builder.alter(blueprint))
+  }
+
+  static async drop(tableName: string): Promise<void> {
+    await this.#addStatement(Builder.drop(tableName))
+  }
+
+  static async dropIfExists(tableName: string): Promise<void> {
+    await this.#addStatement(Builder.dropIfExists(tableName))
+  }
+
+  static async rename(from: string, to: string): Promise<void> {
+    await this.#addStatement(Builder.rename(from, to))
+  }
+
+  static async disableForeignKeyConstraints(): Promise<void> {
+    this.#foreignKeyConstraintsEnabled = false
+    await this.#addStatement('PRAGMA foreign_keys = OFF;')
+  }
+
+  static async enableForeignKeyConstraints(): Promise<void> {
+    this.#foreignKeyConstraintsEnabled = true
+    await this.#addStatement('PRAGMA foreign_keys = ON;')
+  }
+
+  static isForeignKeyConstraintsEnabled(): boolean {
+    return this.#foreignKeyConstraintsEnabled
+  }
+
+  static get sql() {
+    return this.#statements.join('\n\n')
+  }
+  static get raw() {
+    return this.sql
+  }
+
+  // static async dropAllTables(): Promise<void> {
+  //   const tables = await this.getAllTables()
+  //   const sql = Builder.dropAllTables(tables)
+  //   await this.#addStatement(sql)
+  // }
+
+  // static async hasTable(tableName: string): Promise<boolean> {
+  //   if (!this.#c)
+  //     throw new Error('Database connection not set')
+
+  //   const sql = Builder.hasTable(tableName)
+  //   const result = await this.#c.query(sql)
+  //   return result.length > 0
+  // }
+
+  // static async hasColumn(tableName: string, columnName: string): Promise<boolean> {
+  //   if (!this.#c)
+  //     throw new Error('Database connection not set')
+
+  //   const sql = Builder.hasColumn(tableName, 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> {
+  //   if (!this.#c)
+  //     throw new Error('Database connection not set')
+
+  //   const sql = Builder.hasColumn(tableName, '')
+  //   const result = await this.#c.query(sql)
+  //   const existingColumns = result.map((row: any) => row.name)
+
+  //   return columnNames.every(col => existingColumns.includes(col))
+  // }
+
+  // static async getAllTables(): Promise<string[]> {
+  //   if (!this.#c)
+  //     throw new Error('Database connection not set')
+
+  //   const sql = Builder.getAllTables()
+  //   const result = await this.#c.query(sql)
+  //   return result.map((row: any) => row.name)
+  // }
+
+  // static async getColumns(tableName: string): Promise<any[]> {
+  //   if (!this.#c)
+  //     throw new Error('Database connection not set')
+
+  //   const sql = Builder.getColumns(tableName)
+  //   return await this.#c.query(sql)
+  // }
+
+  // static async getColumnType(tableName: string, columnName: string): Promise<string | null> {
+  //   if (!this.#c) {
+  //     throw new Error('Database connection not set')
+  //   }
+
+  //   const sql = Builder.getColumns(tableName)
+  //   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

@@ -0,0 +1,64 @@
+import { Blueprint } from './blueprint'
+import { Migration } from './migration'
+
+export type BlueprintFn = (table: Blueprint) => void
+
+
+// TODO: refactor bellow
+
+export interface ColumnDefinition {
+  name: string,
+  type: string,
+  length?: number,
+  nullable?: boolean,
+  unique?: boolean,
+  primary?: boolean,
+  autoIncrement?: boolean,
+  default?: any,
+  unsigned?: boolean,
+  index?: boolean,
+  comment?: string,
+}
+
+export interface IndexDefinition {
+  columns: string[],
+  type: 'index' | 'unique' | 'primary',
+  name?: string,
+}
+
+export interface ForeignKeyDefinition {
+  column: string,
+  references: string,
+  on: string,
+  onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action',
+  onUpdate?: 'cascade' | 'set null' | 'restrict' | 'no action',
+}
+
+export interface MigrationInfo {
+  timestamp: number,
+  name: string,
+  fileName: string,
+  className: string,
+  handler: MigrationClass,
+}
+
+export interface MigrationRecord {
+  migration: string;
+  batch: number;
+  executed_at: Date;
+}
+
+export type MigrationClass = {
+  // new (): MigrationClass;
+  // new(): Migration;
+  // up(): Promise<void>;
+  // down(): Promise<void>;
+  run(): Promise<void>
+  // toSQL?(): Promise<string>;
+  // getMigrationName?(): string;
+}
+
+// export interface SchemaConnection {
+//   execute(sql: string): Promise<any>,
+//   query(sql: string): Promise<any[]>,
+// }

package/src/model.ts

@@ -15,7 +15,7 @@ export default abstract class Model<TB extends keyof DB, DB> {
   static $schema?: DBSchema
 
   static pipe<S, T>(): Pipe<S, T> {
-    throw new Error(`Database connection not provided.`) // improv this message
+    throw new Error(`Database connection not provided.`) // TODO: improv this message
   }
 
   static builder<S, T>() {