@stacksjs/database 0.58.73 → 0.59.1

package/dist/column.d.ts

@@ -0,0 +1,18 @@
+interface Options {
+    notNull?: boolean;
+    default?: any;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+}
+type ColumnType = 'integer' | 'varchar' | 'timestamp';
+export declare class Column {
+    name: string;
+    type: ColumnType;
+    options: Options;
+    constructor(name: string, type: ColumnType, options?: Options);
+    notNullable(): this;
+    defaultTo(value: any): this;
+    primary(): this;
+    autoIncrement(): this;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { Kysely } from 'kysely';
+import type { ColumnType, Generated } from 'kysely';
+export * from './schema';
+export * from './migrations';
+export * from './types';
+export * from './utils';
+export interface UsersTable {
+    id: Generated<number>;
+    name: string;
+    email: string;
+    password: string;
+    created_at: ColumnType<Date, string | undefined, never>;
+    deleted_at: ColumnType<Date, string | undefined, never>;
+}
+export interface Database {
+    users: UsersTable;
+}
+export declare const db: Kysely<Database>;
+export declare const dbDialect: any;

package/dist/migrations.d.ts

@@ -0,0 +1,6 @@
+export interface MigrationOptions {
+    name: string;
+    up: string;
+    down: string;
+}
+export declare function generateMigrationFile(options: MigrationOptions): void;

package/dist/schema.d.ts

@@ -0,0 +1,4 @@
+import { Table } from './table';
+export declare class Schema {
+    static createTable(tableName: string, callback: (table: Table) => void): Promise<void>;
+}

package/dist/table.d.ts

@@ -0,0 +1,8 @@
+import { Column } from './column';
+export declare class Table {
+    private columns;
+    increments(name: string): Column;
+    string(name: string, varchar?: number): Column;
+    timestamps(): void;
+    execute(): void;
+}

package/dist/types.d.ts

@@ -0,0 +1 @@
+export { Kysely as Migration } from 'kysely';

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare const now: import("kysely").RawBuilder<unknown>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.58.73",
+  "version": "0.59.1",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -71,7 +71,7 @@
     "kysely-bun-worker": "^0.5.7"
   },
   "optionalDependencies": {
-    "mysql2": "^3.9.1"
+    "mysql2": "^3.9.2"
   },
   "devDependencies": {
     "@stacksjs/development": "latest"

package/src/column.ts

@@ -0,0 +1,32 @@
+interface Options {
+  notNull?: boolean
+  default?: any
+  primaryKey?: boolean
+  autoIncrement?: boolean
+}
+
+type ColumnType = 'integer' | 'varchar' | 'timestamp'
+
+export class Column {
+  constructor(public name: string, public type: ColumnType, public options: Options = {}) {}
+
+  notNullable(): this {
+    this.options.notNull = true
+    return this
+  }
+
+  defaultTo(value: any): this {
+    this.options.default = value
+    return this
+  }
+
+  primary(): this {
+    this.options.primaryKey = true
+    return this
+  }
+
+  autoIncrement(): this {
+    this.options.autoIncrement = true
+    return this
+  }
+}

package/src/index.ts

@@ -1,10 +1,14 @@
-// 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'
 
+export * from './schema'
+export * from './migrations'
+export * from './types'
+export * from './utils'
+
 // const driver = config.database.default
 const driver = 'mysql'
 

package/src/schema.ts

@@ -0,0 +1,11 @@
+import { Table } from './table'
+
+export class Schema {
+  static async createTable(tableName: string, callback: (table: Table) => void): Promise<void> {
+    const table = new Table()
+    callback(table)
+    table.execute() // Simulate the execution of the table creation
+    // eslint-disable-next-line no-console
+    console.log(`Table "${tableName}" created.`)
+  }
+}

package/src/table.ts

@@ -0,0 +1,29 @@
+import { Column } from './column'
+
+export class Table {
+  private columns: Column[] = []
+
+  increments(name: string): Column {
+    const column = new Column(name, 'integer', { primaryKey: true, autoIncrement: true })
+    this.columns.push(column)
+    return column
+  }
+
+  string(name: string, varchar: number = 255): Column {
+    const column = new Column(name, `varchar(${varchar})`)
+    this.columns.push(column)
+    return column
+  }
+
+  timestamps(): void {
+    this.columns.push(new Column('created_at', 'timestamp'))
+    this.columns.push(new Column('updated_at', 'timestamp'))
+  }
+
+  // Method to simulate the execution of the schema definition
+  execute(): void {
+    // eslint-disable-next-line no-console
+    console.log(`Creating table with columns: ${this.columns.map(col => col.name).join(', ')}`)
+    // Here you would normally execute the SQL commands to create the table and columns in the database
+  }
+}

package/src/types.ts

@@ -0,0 +1 @@
+export { Kysely as Migration } from 'kysely'

package/src/utils.ts

@@ -0,0 +1,3 @@
+import { sql } from 'kysely'
+
+export const now = sql`now()`

package/dist/index.js

@@ -1,200 +0,0 @@
-// @bun
-// src/index.ts
-import {Kysely, MysqlDialect} from "kysely";
-import {createPool} from "mysql2";
-
-// src/kysely-bun-worker/index.ts
-import {SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler} from "kysely";
-
-// src/kysely-bun-worker/driver.ts
-import {CompiledQuery} from "kysely";
-
-// ../../../../node_modules/mitt/dist/mitt.mjs
-function mitt_default(n) {
-  return { all: n = n || new Map, on: function(t, e) {
-    var i = n.get(t);
-    i ? i.push(e) : n.set(t, [e]);
-  }, off: function(t, e) {
-    var i = n.get(t);
-    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
-  }, emit: function(t, e) {
-    var i = n.get(t);
-    i && i.slice().map(function(n2) {
-      n2(e);
-    }), (i = n.get("*")) && i.slice().map(function(n2) {
-      n2(t, e);
-    });
-  } };
-}
-
-// src/kysely-bun-worker/mitt.ts
-function mittOnce(all) {
-  const emitter = mitt_default(all);
-  return {
-    ...emitter,
-    once(type, handler) {
-      const fn = (arg) => {
-        emitter.off(type, fn);
-        handler(arg);
-      };
-      emitter.on(type, fn);
-    }
-  };
-}
-
-// src/kysely-bun-worker/driver.ts
-class BunWorkerDriver {
-  config;
-  worker;
-  connection;
-  connectionMutex = new ConnectionMutex;
-  mitt;
-  constructor(config) {
-    this.config = config;
-  }
-  async init() {
-    this.worker = this.config?.worker ?? new Worker(new URL("../src/kysely-bun-worker/worker", import.meta.url), { type: "module" });
-    this.mitt = mittOnce();
-    this.worker.onmessage = ({ data: { data, err, type } }) => {
-      this.mitt?.emit(type, { data, err });
-    };
-    const msg = {
-      type: "init",
-      url: this.config?.url ?? ":memory:",
-      cache: this.config?.cacheStatment ?? false
-    };
-    this.worker.postMessage(msg);
-    await new Promise((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() {
-    await this.connectionMutex.lock();
-    return this.connection;
-  }
-  async beginTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("begin"));
-  }
-  async commitTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("commit"));
-  }
-  async rollbackTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("rollback"));
-  }
-  async releaseConnection() {
-    this.connectionMutex.unlock();
-  }
-  async destroy() {
-    if (!this.worker)
-      return;
-    this.worker.postMessage({
-      type: "close"
-    });
-    return new Promise((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 {
-  promise;
-  resolve;
-  async lock() {
-    while (this.promise)
-      await this.promise;
-    this.promise = new Promise((resolve) => {
-      this.resolve = resolve;
-    });
-  }
-  unlock() {
-    const resolve = this.resolve;
-    this.promise = undefined;
-    this.resolve = undefined;
-    resolve?.();
-  }
-}
-
-class BunWorkerConnection {
-  worker;
-  mitt;
-  constructor(worker, mitt2) {
-    this.worker = worker;
-    this.mitt = mitt2;
-  }
-  streamQuery() {
-    throw new Error("Sqlite driver doesn\'t support streaming");
-  }
-  async executeQuery(compiledQuery) {
-    const { parameters, sql, query } = compiledQuery;
-    const mode = query.kind === "SelectQueryNode" ? "query" : query.kind === "RawNode" ? "raw" : "exec";
-    const msg = { 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);
-      });
-    });
-  }
-}
-
-// src/kysely-bun-worker/index.ts
-class BunWorkerDialect {
-  #config;
-  constructor(config) {
-    this.#config = config;
-  }
-  createDriver() {
-    return new BunWorkerDriver(this.#config);
-  }
-  createQueryCompiler() {
-    return new SqliteQueryCompiler;
-  }
-  createAdapter() {
-    return new SqliteAdapter;
-  }
-  createIntrospector(db) {
-    return new SqliteIntrospector(db);
-  }
-}
-
-// src/index.ts
-var driver2 = "mysql";
-var dialect;
-if (driver2 === "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
-    })
-  });
-}
-var db = new Kysely({
-  dialect
-});
-var dbDialect = dialect;
-export {
-  dbDialect,
-  db
-};

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

@@ -1,144 +0,0 @@
-/* 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

@@ -1,46 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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,
-  }
-}
-
-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 → migrations.ts}

@@ -1,7 +1,7 @@
-// import { storage } from '@stacksjs/storage'
 import { path as p } from '@stacksjs/path'
 import { log } from '@stacksjs/cli'
 
+// import { storage } from '@stacksjs/storage'
 // import type { Model, SchemaOptions } from '@stacksjs/types'
 // import { titleCase } from '@stacksjs/strings'