@stacksjs/database 0.58.48 → 0.58.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.49",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -42,7 +42,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/index.ts

@@ -0,0 +1,63 @@
+// export * from './migrations'
+// export * from './seeder''
+import { Kysely, MysqlDialect } from 'kysely'
+import { createPool } from 'mysql2'
+import type { ColumnType, Generated } from 'kysely'
+import { BunWorkerDialect } from './kysely-bun-worker'
+
+// const driver = config.database.default
+const driver = 'mysql'
+
+// const dbName = config.database.name
+
+export interface UsersTable {
+  // Columns that are generated by the database should be marked
+  // using the `Generated` type. This way they are automatically
+  // made optional in inserts and updates.
+  id: Generated<number>
+
+  name: string
+  email: string
+
+  // If the column is nullable in the database, make its type nullable.
+  // Don't use optional properties. Optionality is always determined
+  // automatically by Kysely.
+  password: string
+
+  // You can specify a different type for each operation (select, insert and
+  // update) using the `ColumnType<SelectType, InsertType, UpdateType>`
+  // wrapper. Here we define a column `created_at` that is selected as
+  // a `Date`, can optionally be provided as a `string` in inserts and
+  // can never be updated:
+  created_at: ColumnType<Date, string | undefined, never>
+  deleted_at: ColumnType<Date, string | undefined, never>
+}
+
+export interface Database {
+  users: UsersTable
+}
+
+let dialect
+
+if (driver === 'sqlite') {
+  dialect = new BunWorkerDialect({
+    url: 'stacks.sqlite',
+  })
+}
+else {
+  dialect = new MysqlDialect({
+    pool: createPool({
+      database: 'stacks',
+      host: '127.0.0.1',
+      user: 'root',
+      password: '',
+      port: 3306,
+    }),
+  })
+}
+
+export const db = new Kysely<Database>({
+  dialect,
+})
+
+export const dbDialect = dialect

package/src/kysely-bun-worker/driver.ts

@@ -0,0 +1,144 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+import type { DatabaseConnection, Driver, QueryResult } from 'kysely'
+import { CompiledQuery } from 'kysely'
+import type { EmitterOnce } from './mitt'
+import MittOnce from './mitt'
+import type { EventWithError, MainMsg, WorkerMsg } from './type'
+import type { BunWorkerDialectConfig } from '.'
+
+export class BunWorkerDriver implements Driver {
+  private config?: BunWorkerDialectConfig
+  private worker?: Worker
+  private connection?: DatabaseConnection
+  private connectionMutex = new ConnectionMutex()
+  private mitt?: EmitterOnce<EventWithError>
+  constructor(config?: BunWorkerDialectConfig) {
+    this.config = config
+  }
+
+  async init(): Promise<void> {
+    this.worker = this.config?.worker ?? new Worker(
+      new URL('../src/kysely-bun-worker/worker', import.meta.url),
+      { type: 'module' },
+    )
+    this.mitt = MittOnce<EventWithError>()
+    this.worker.onmessage = ({ data: { data, err, type } }: MessageEvent<WorkerMsg>) => {
+      this.mitt?.emit(type, { data, err })
+    }
+    const msg: MainMsg = {
+      type: 'init',
+      url: this.config?.url ?? ':memory:',
+      cache: this.config?.cacheStatment ?? false,
+    }
+    this.worker.postMessage(msg)
+    await new Promise<void>((resolve, reject) => {
+      this.mitt?.once('init', ({ err }) => {
+        err ? reject(err) : resolve()
+      })
+    })
+    this.connection = new BunWorkerConnection(this.worker, this.mitt)
+
+    await this.config?.onCreateConnection?.(this.connection)
+  }
+
+  async acquireConnection(): Promise<DatabaseConnection> {
+    // SQLite only has one single connection. We use a mutex here to wait
+    // until the single connection has been released.
+    await this.connectionMutex.lock()
+    return this.connection!
+  }
+
+  async beginTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw('begin'))
+  }
+
+  async commitTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw('commit'))
+  }
+
+  async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw('rollback'))
+  }
+
+  async releaseConnection(): Promise<void> {
+    this.connectionMutex.unlock()
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.worker)
+      return
+
+    this.worker.postMessage({
+      type: 'close',
+    })
+    return new Promise<void>((resolve, reject) => {
+      this.mitt?.once('close', ({ err }) => {
+        if (err) {
+          reject(err)
+        }
+        else {
+          this.worker?.terminate()
+          this.mitt?.all.clear()
+          this.mitt = undefined
+          resolve()
+        }
+      })
+    })
+  }
+}
+
+class ConnectionMutex {
+  private promise?: Promise<void>
+  private resolve?: () => void
+
+  async lock(): Promise<void> {
+    while (this.promise)
+      await this.promise
+
+    this.promise = new Promise((resolve) => {
+      this.resolve = resolve
+    })
+  }
+
+  unlock(): void {
+    const resolve = this.resolve
+
+    this.promise = undefined
+    this.resolve = undefined
+
+    resolve?.()
+  }
+}
+
+class BunWorkerConnection implements DatabaseConnection {
+  readonly worker: Worker
+  readonly mitt?: EmitterOnce<EventWithError>
+  constructor(worker: Worker, mitt?: EmitterOnce<EventWithError>) {
+    this.worker = worker
+    this.mitt = mitt
+  }
+
+  streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {
+    throw new Error('Sqlite driver doesn\'t support streaming')
+  }
+
+  async executeQuery<R>(compiledQuery: CompiledQuery<unknown>): Promise<QueryResult<R>> {
+    const { parameters, sql, query } = compiledQuery
+    const mode = query.kind === 'SelectQueryNode'
+      ? 'query'
+      : query.kind === 'RawNode'
+        ? 'raw'
+        : 'exec'
+    const msg: MainMsg = { type: 'run', mode, sql, parameters }
+    this.worker.postMessage(msg)
+    return new Promise((resolve, reject) => {
+      if (!this.mitt)
+        reject('kysely instance has been destroyed')
+
+      this.mitt.once('run', ({ data, err }) => {
+        (!err && data) ? resolve(data) : reject(err)
+      })
+    })
+  }
+}

package/src/kysely-bun-worker/index.ts

@@ -0,0 +1,46 @@
+import type { DatabaseConnection, DatabaseIntrospector, Dialect, DialectAdapter, Driver, Kysely, QueryCompiler } from 'kysely'
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from 'kysely'
+import { BunWorkerDriver } from './driver'
+import type { Promisable } from './type'
+
+export interface BunWorkerDialectConfig {
+  /**
+   * db file path
+   *
+   * @default ':memory:'
+   */
+  url?: string
+  onCreateConnection?: (connection: DatabaseConnection) => Promisable<void>
+  /**
+   * use bun:sqlite's built-in statment cache
+   * @see https://bun.sh/docs/api/sqlite#query
+   */
+  cacheStatment?: boolean
+  /**
+   * custom worker, default is a worker that use bun:sqlite
+   */
+  worker?: Worker
+}
+
+export class BunWorkerDialect implements Dialect {
+  #config?: BunWorkerDialectConfig
+  constructor(config?: BunWorkerDialectConfig) {
+    this.#config = config
+  }
+
+  createDriver(): Driver {
+    return new BunWorkerDriver(this.#config)
+  }
+
+  createQueryCompiler(): QueryCompiler {
+    return new SqliteQueryCompiler()
+  }
+
+  createAdapter(): DialectAdapter {
+    return new SqliteAdapter()
+  }
+
+  createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+    return new SqliteIntrospector(db)
+  }
+}

package/src/kysely-bun-worker/mitt.ts

@@ -0,0 +1,24 @@
+import type { Emitter, EventHandlerMap, EventType, Handler } from 'mitt'
+import mitt from 'mitt'
+
+export interface EmitterOnce<Events extends Record<EventType, unknown>> extends Emitter<Events> {
+  once<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void
+}
+
+export default function mittOnce<Events extends Record<EventType, unknown>>(
+  all?: EventHandlerMap<Events>,
+): EmitterOnce<Events> {
+  const emitter = mitt<Events>(all)
+
+  return {
+    ...emitter,
+
+    once<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>) {
+      const fn = (arg: Events[Key]) => {
+        emitter.off(type, fn)
+        handler(arg)
+      }
+      emitter.on(type, fn)
+    },
+  }
+}

package/src/kysely-bun-worker/type.ts

@@ -0,0 +1,40 @@
+import type { QueryResult } from 'kysely'
+
+export type Promisable<T> = T | Promise<T>
+
+export type RunMode = 'exec' | 'query' | 'raw'
+
+export type MainMsg =
+  | {
+    type: 'run'
+    mode: RunMode
+    sql: string
+    parameters?: readonly unknown[]
+  }
+  | {
+    type: 'close'
+  }
+  | {
+    type: 'init'
+    url: string
+    cache: boolean
+  }
+
+export type WorkerMsg = {
+  [K in keyof Events]: {
+    type: K
+    data: Events[K]
+    err: unknown
+  }
+}[keyof Events]
+interface Events {
+  run: QueryResult<any> | null
+  init: null
+  close: null
+}
+export type EventWithError = {
+  [K in keyof Events]: {
+    data: Events[K]
+    err: unknown
+  }
+}

package/src/kysely-bun-worker/worker.ts

@@ -0,0 +1,53 @@
+import Database from 'bun:sqlite'
+import type { QueryResult } from 'kysely'
+import type { MainMsg, RunMode, WorkerMsg } from './type'
+
+let db: Database
+let cache: boolean
+function run(mode: RunMode, sql: string, parameters?: readonly unknown[]): QueryResult<any> {
+  const stmt = db[cache ? 'query' : 'prepare'](sql)
+
+  let rows: unknown[] = []
+  if (mode !== 'exec')
+
+    rows = stmt.all(parameters as any)
+
+  if (mode === 'query')
+    return { rows }
+
+  stmt.run(parameters as any)
+  return {
+    rows,
+    // @ts-expect-error get insert id
+    insertId: db.query('SELECT last_insert_rowid() as i').get().i,
+    // @ts-expect-error get changes
+    numAffectedRows: db.query('SELECT changes() as c').get().c,
+  }
+}
+
+// @ts-expect-error bun worker
+onmessage = ({ data }: MessageEvent<MainMsg>) => {
+  const ret: WorkerMsg = {
+    type: data.type,
+    data: null,
+    err: null,
+  }
+  try {
+    switch (data.type) {
+      case 'run':
+        ret.data = run(data.mode, data.sql, data.parameters)
+        break
+      case 'close':
+        db.close()
+        break
+      case 'init':
+        db = new Database(data.url, { create: true })
+        cache = data.cache
+        break
+    }
+  }
+  catch (error) {
+    ret.err = error
+  }
+  postMessage(ret)
+}

package/src/migrations/index.ts

@@ -0,0 +1,73 @@
+// import { storage } from '@stacksjs/storage'
+import { path as p } from '@stacksjs/path'
+import { log } from '@stacksjs/cli'
+
+// import type { Model, SchemaOptions } from '@stacksjs/types'
+// import { titleCase } from '@stacksjs/strings'
+
+// const { fs } = storage
+
+// function readModelsFromFolder(folderPath: string): Promise<Model[]> {
+//   return new Promise((resolve, reject) => {
+//     const models: Model[] = []
+
+//     fs.readdir(folderPath, (err, files) => {
+//       if (err)
+//         reject(err)
+
+//       const promises = files
+//         .filter(file => file.endsWith('.ts'))
+//         .map((file) => {
+//           const filePath = `${folderPath}/${file}`
+
+//           return import(filePath).then((data) => {
+//             models.push({
+//               name: data.default.name,
+//               fields: data.default.fields,
+//             })
+//           })
+//         })
+
+//       Promise.all(promises)
+//         .then(() => resolve(models))
+//         .catch(err => reject(err))
+//     })
+//   })
+// }
+
+// async function migrate(path: string, options: SchemaOptions): Promise<void> {
+//   const models = await readModelsFromFolder(projectPath('app/Models'))
+
+//   generatePrismaSchema(models, path, options)
+// }
+
+export interface MigrationOptions {
+  name: string
+  up: string
+  down: string
+}
+
+export function generateMigrationFile(options: MigrationOptions) {
+  const { name, up, down } = options
+
+  const timestamp = new Date().getTime().toString()
+  const fileName = `${timestamp}-${name}.ts`
+  const filePath = p.frameworkPath(`database/migrations/${fileName}`)
+  const fileContent = `
+    import { Migration } from '@stacksjs/database'
+
+    export default new Migration({
+      name: '${name}',
+      up: \`
+        ${up}
+      \`,
+      down: \`
+        ${down}
+      \`,
+    })
+  `
+  // TODO: use Bun.write
+  fs.writeFileSync(filePath, fileContent)
+
+  log.info(`Created migration file: ${fileName}`)
+}

package/src/seeder/index.ts

@@ -0,0 +1,79 @@
+// import { MysqlDialect, QueryBuilder, createPool } from '@stacksjs/query-builder'
+// import { filesystem } from '@stacksjs/storage'
+// import type { Model } from '@stacksjs/types'
+// import { projectPath } from '@stacksjs/path'
+// import { database as config } from '@stacksjs/config'
+
+// const { fs } = filesystem
+
+// function readModels(folderPath: string): Promise<Model[]> {
+//   return new Promise((resolve, reject) => {
+//     const models: Model[] = []
+
+//     fs.readdir(folderPath, (err, files) => {
+//       if (err)
+//         reject(err)
+
+//       const promises = files
+//         .filter(file => file.endsWith('.ts'))
+//         .map((file) => {
+//           const filePath = `${folderPath}/${file}`
+
+//           return import(filePath).then((data) => {
+//             models.push({
+//               name: data.default.name,
+//               fields: data.default.fields,
+//               useSeed: data.default.useSeed,
+//             })
+//           })
+//         })
+
+//       Promise.all(promises)
+//         .then(() => resolve(models))
+//         .catch(err => reject(err))
+//     })
+//   })
+// }
+
+async function seed() {
+  // const db = new QueryBuilder({
+  //   dialect: new MysqlDialect({
+  //     pool: createPool({
+  //       database: config.database,
+  //       host: config.host,
+  //       password: config.password,
+  //       user: config.username,
+  //     }),
+  //   }),
+  // })
+
+  // const models = await readModels(projectPath('app/Models'))
+
+  // const queries = models.flatMap((model) => {
+  //   const { seedable, fields } = model
+
+  //   if (!seedable)
+  //     return []
+
+  //   const count = typeof seedable === 'boolean' ? 10 : seedable.count
+
+  //   const records: Record<string, any>[] = []
+  //   for (let i = 0; i < count; i++) {
+  //     const record: Record<string, any> = {}
+  //     Object.entries(fields).forEach(([name, field]) => {
+  //       if (field.factory)
+  //         record[name] = field.factory()
+  //     })
+  //     records.push(record)
+  //   }
+
+  //     return model
+  //   // return db.insertInto('users').values(records).build(sql`RETURNING *`)
+  // })
+
+  // const { rows } = await db.transaction().execute()
+
+  // return rows
+}
+
+export { seed }