mevn-orm 4.0.0 → 4.0.2

package/initDb.ts

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-import { existsSync } from 'node:fs'
-import { pathToFileURL } from 'node:url'
-import 'dotenv/config'
-import type { Knex } from 'knex'
-import knexModule from 'knex'
-
-interface KnexEnvConfig {
-	development: Knex.Config
-	staging: Knex.Config
-	production: Knex.Config
-}
-
-type KnexFactory = (config: Knex.Config) => Knex
-
-const KnexFactoryImpl: KnexFactory =
-	(knexModule as unknown as { knex?: KnexFactory }).knex ??
-	(knexModule as unknown as KnexFactory)
-
-const knexfilePath = `${process.cwd()}/knexfile.ts`
-if (!existsSync(knexfilePath)) {
-	throw new Error('knexfile.ts not found in current working directory')
-}
-
-const knexConfigModule = await import(pathToFileURL(knexfilePath).href)
-const knexConfig = (knexConfigModule.default ?? knexConfigModule) as Partial<KnexEnvConfig>
-const { development, staging, production } = knexConfig
-
-if (!development || !staging || !production) {
-	throw new Error('knexfile.ts must export development, staging, and production config')
-}
-
-const config: Knex.Config = (() => {
-	switch (process.env.NODE_ENV) {
-	case 'testing':
-	case 'test':
-	case 'development':
-		return development
-	case 'staging':
-		return staging
-	default:
-		return production
-	}
-})()
-
-const initDatabase = async (): Promise<void> => {
-	const DB = KnexFactoryImpl(config)
-
-	try {
-		await DB.schema.dropTableIfExists('farmers')
-		await DB.schema.dropTableIfExists('farms')
-		await DB.schema.dropTableIfExists('profiles')
-		await DB.schema.dropTableIfExists('articles')
-
-		await DB.schema.createTable('farmers', (table: Knex.CreateTableBuilder) => {
-			table.bigIncrements('id')
-			table.string('name')
-			table.string('email').unique()
-			table.string('password')
-		})
-
-		await DB.schema.createTable('farms', (table: Knex.CreateTableBuilder) => {
-			table.bigIncrements('id')
-			table.bigInteger('farmer_id')
-			table.string('name')
-		})
-
-		await DB.schema.createTable('profiles', (table: Knex.CreateTableBuilder) => {
-			table.bigIncrements('id')
-			table.bigInteger('farmer_id')
-			table.string('bio')
-		})
-
-		await DB.schema.createTable('articles', (table: Knex.CreateTableBuilder) => {
-			table.bigIncrements('id')
-			table.string('title')
-			table.text('body')
-			table.bigInteger('postable_id')
-			table.string('postable_type')
-		})
-
-		await DB.table('Farmers').insert([
-			{ name: 'Jane Doe', email: 'jane@mail.com', password: 'pasword' },
-			{ name: 'Ashley Doe', email: 'ashley@mail.com', password: 'pasword' },
-			{ name: 'Alice Doe', email: 'alice@mail.com', password: 'pasword' },
-		])
-
-		await DB.table('farms').insert([
-			{ farmer_id: 1, name: 'Awesome Farm' },
-			{ farmer_id: 1, name: 'Awesome Farm two' },
-			{ farmer_id: 1, name: 'Awesome Farm three' },
-		])
-
-		await DB.table('profiles').insert([{ farmer_id: 1, bio: 'Profile for farmer one' }])
-
-		await DB.table('articles').insert([
-			{
-				title: 'Awesome Post',
-				body: 'fffgjdfjdbdb something #1',
-				postable_id: 1,
-				postable_type: 'Farmer',
-			},
-		])
-
-		process.exit(0)
-	} catch (error: unknown) {
-		console.error(error)
-		process.exit(1)
-	}
-}
-
-await initDatabase()

package/knexfile.ts

@@ -1,46 +0,0 @@
-import type { Knex } from 'knex'
-
-const config = {
-	development: {
-		client: 'sqlite3',
-		connection: {
-			filename: './dev.sqlite',
-		},
-		useNullAsDefault: true,
-		migrations: {
-			tableName: 'migrations',
-		},
-	},
-	staging: {
-		client: process.env.DB_CLIENT ?? 'mysql2',
-		connection: {
-			database: process.env.DB_DATABASE ?? 'my_db',
-			user: process.env.DB_USER ?? 'username',
-			password: process.env.DB_PASSWORD ?? 'password',
-		},
-		pool: {
-			min: 2,
-			max: 10,
-		},
-		migrations: {
-			tableName: 'migrations',
-		},
-	},
-	production: {
-		client: process.env.DB_CLIENT ?? 'mysql2',
-		connection: {
-			database: process.env.DB_DATABASE ?? 'my_db',
-			user: process.env.DB_USER ?? 'username',
-			password: process.env.DB_PASSWORD ?? 'password',
-		},
-		pool: {
-			min: 2,
-			max: 10,
-		},
-		migrations: {
-			tableName: 'migrations',
-		},
-	},
-} satisfies Record<'development' | 'staging' | 'production', Knex.Config>
-
-export default config

package/pnpm-workspace.yaml

@@ -1,9 +0,0 @@
-onlyBuiltDependencies:
-  - esbuild
-  - sqlite3
-
-overrides:
-  diff@>=6.0.0 <8.0.3: '>=8.0.3'
-  tar@<7.5.7: '>=7.5.7'
-  tar@<=7.5.2: '>=7.5.3'
-  tar@<=7.5.3: '>=7.5.4'

package/scripts/migrate.ts

@@ -1,97 +0,0 @@
-#!/usr/bin/env node
-import {
-	configureDatabase,
-	setMigrationConfig,
-	makeMigration,
-	migrateLatest,
-	migrateRollback,
-	migrateList,
-	migrateCurrentVersion,
-} from '../index.js'
-
-const [command = 'latest', name] = process.argv.slice(2)
-
-const databaseConfig: Parameters<typeof configureDatabase>[0] = {
-	dialect: (process.env.DB_DIALECT as
-		| 'sqlite'
-		| 'better-sqlite3'
-		| 'mysql'
-		| 'mysql2'
-		| 'postgres'
-		| 'postgresql'
-		| 'pg'
-		| 'pgnative'
-		| 'cockroachdb'
-		| 'redshift'
-		| 'mssql'
-		| 'oracledb'
-		| 'oracle') ?? 'sqlite',
-	filename: process.env.DB_FILENAME ?? './dev.sqlite',
-}
-
-if (process.env.DATABASE_URL) {
-	databaseConfig.connectionString = process.env.DATABASE_URL
-}
-if (process.env.DB_HOST) {
-	databaseConfig.host = process.env.DB_HOST
-}
-if (process.env.DB_PORT) {
-	databaseConfig.port = Number(process.env.DB_PORT)
-}
-if (process.env.DB_USER) {
-	databaseConfig.user = process.env.DB_USER
-}
-if (process.env.DB_PASSWORD) {
-	databaseConfig.password = process.env.DB_PASSWORD
-}
-if (process.env.DB_NAME) {
-	databaseConfig.database = process.env.DB_NAME
-}
-if (process.env.DB_SSL === 'true') {
-	databaseConfig.ssl = true
-}
-
-configureDatabase(databaseConfig)
-
-setMigrationConfig({
-	directory: process.env.MIGRATIONS_DIR ?? './migrations',
-	extension: process.env.MIGRATIONS_EXT ?? 'ts',
-})
-
-const run = async (): Promise<void> => {
-	switch (command) {
-	case 'make': {
-		if (!name) {
-			throw new Error('Usage: node --import tsx scripts/migrate.ts make <name>')
-		}
-		const file = await makeMigration(name)
-		console.log(file)
-		return
-	}
-	case 'latest': {
-		const result = await migrateLatest()
-		console.log(JSON.stringify(result, null, 2))
-		return
-	}
-	case 'rollback': {
-		const all = process.argv.includes('--all')
-		const result = await migrateRollback(undefined, all)
-		console.log(JSON.stringify(result, null, 2))
-		return
-	}
-	case 'list': {
-		const result = await migrateList()
-		console.log(JSON.stringify(result, null, 2))
-		return
-	}
-	case 'version': {
-		const version = await migrateCurrentVersion()
-		console.log(version)
-		return
-	}
-	default:
-		throw new Error(`Unknown command "${command}". Use make|latest|rollback|list|version`)
-	}
-}
-
-await run()

package/src/config.ts

@@ -1,270 +0,0 @@
-import type { Knex } from 'knex'
-import knexModule from 'knex'
-
-type KnexFactory = (config: Knex.Config) => Knex
-
-const knexFactory: KnexFactory =
-	(knexModule as unknown as { knex?: KnexFactory }).knex ??
-	(knexModule as unknown as KnexFactory)
-
-const toError = (error: unknown): Error => {
-	if (error instanceof Error) {
-		return error
-	}
-
-	return new Error(String(error))
-}
-
-let DB: Knex | undefined
-let defaultMigrationConfig: Knex.MigratorConfig = {}
-
-type SimpleDialect =
-	| 'sqlite'
-	| 'better-sqlite3'
-	| 'mysql'
-	| 'mysql2'
-	| 'postgres'
-	| 'postgresql'
-	| 'pg'
-	| 'pgnative'
-	| 'cockroachdb'
-	| 'redshift'
-	| 'mssql'
-	| 'oracledb'
-	| 'oracle'
-
-interface SimpleDatabaseConfig {
-	dialect: SimpleDialect
-	connectionString?: string
-	filename?: string
-	host?: string
-	port?: number
-	user?: string
-	password?: string
-	database?: string
-	ssl?: boolean | Record<string, unknown>
-	debug?: boolean
-	pool?: Knex.PoolConfig
-}
-
-interface MigrationResult {
-	batch: number
-	log: string[]
-}
-
-/** Returns the active Knex instance or throws if the ORM has not been configured. */
-const getDB = (): Knex => {
-	if (!DB) {
-		throw new Error('Mevn ORM is not configured. Call configure({ client, connection, ... }) before using Model.')
-	}
-
-	return DB
-}
-
-/** Configures the ORM using a Knex config object or an existing Knex instance. */
-const configure = (config: Knex.Config | Knex): Knex => {
-	if (typeof config === 'function') {
-		DB = config
-		return DB
-	}
-
-	DB = knexFactory(config)
-	return DB
-}
-
-/** Sets default migration options used by migration helpers. */
-const setMigrationConfig = (config: Knex.MigratorConfig): Knex.MigratorConfig => {
-	defaultMigrationConfig = { ...config }
-	return { ...defaultMigrationConfig }
-}
-
-/** Returns the currently configured default migration options. */
-const getMigrationConfig = (): Knex.MigratorConfig => ({ ...defaultMigrationConfig })
-
-const resolveMigrationConfig = (config?: Knex.MigratorConfig): Knex.MigratorConfig => ({
-	...defaultMigrationConfig,
-	...(config ?? {}),
-})
-
-const normalizeDialect = (dialect: SimpleDialect): string => {
-	switch (dialect) {
-	case 'sqlite':
-		return 'sqlite3'
-	case 'mysql':
-		return 'mysql2'
-	case 'postgres':
-	case 'postgresql':
-	case 'pg':
-		return 'pg'
-	case 'oracle':
-		return 'oracledb'
-	default:
-		return dialect
-	}
-}
-
-const requireField = (value: unknown, field: string, dialect: string): void => {
-	if (value === undefined || value === null || value === '') {
-		throw new Error(`Missing required field "${field}" for dialect "${dialect}".`)
-	}
-}
-
-const buildConnection = (config: SimpleDatabaseConfig): NonNullable<Knex.Config['connection']> => {
-	if (config.connectionString) {
-		return config.connectionString
-	}
-
-	const client = normalizeDialect(config.dialect)
-
-	if (client === 'sqlite3' || client === 'better-sqlite3') {
-		requireField(config.filename, 'filename', config.dialect)
-		return { filename: config.filename as string }
-	}
-
-	if (client === 'mssql') {
-		const server = config.host
-		requireField(server, 'host', config.dialect)
-		requireField(config.user, 'user', config.dialect)
-		requireField(config.database, 'database', config.dialect)
-		const connection: Record<string, unknown> = {
-			server: server as string,
-			user: config.user as string,
-			database: config.database as string,
-		}
-		if (typeof config.port === 'number') {
-			connection.port = config.port
-		}
-		if (config.password !== undefined) {
-			connection.password = config.password
-		}
-		if (config.ssl) {
-			connection.options = { encrypt: true }
-		}
-		return connection
-	}
-
-	requireField(config.host, 'host', config.dialect)
-	requireField(config.user, 'user', config.dialect)
-	requireField(config.database, 'database', config.dialect)
-	const connection: Record<string, unknown> = {
-		host: config.host as string,
-		user: config.user as string,
-		database: config.database as string,
-	}
-	if (typeof config.port === 'number') {
-		connection.port = config.port
-	}
-	if (config.password !== undefined) {
-		connection.password = config.password
-	}
-	if (config.ssl !== undefined) {
-		connection.ssl = config.ssl
-	}
-	return connection
-}
-
-/** Builds a Knex config from a simplified, dialect-first configuration object. */
-const createKnexConfig = (config: SimpleDatabaseConfig): Knex.Config => {
-	const client = normalizeDialect(config.dialect)
-	const base: Knex.Config = {
-		client,
-		connection: buildConnection(config),
-	}
-	if (config.pool) {
-		base.pool = config.pool
-	}
-	if (typeof config.debug === 'boolean') {
-		base.debug = config.debug
-	}
-
-	if (client === 'sqlite3') {
-		base.useNullAsDefault = true
-	}
-
-	return base
-}
-
-/** Configures the ORM from simplified database options. */
-const configureDatabase = (config: SimpleDatabaseConfig): Knex => configure(createKnexConfig(config))
-
-/** Generates a migration file and returns its path. */
-const makeMigration = async (name: string, config?: Knex.MigratorConfig): Promise<string> => {
-	try {
-		return await getDB().migrate.make(name, resolveMigrationConfig(config))
-	} catch (error) {
-		throw toError(error)
-	}
-}
-
-/** Runs pending migrations and returns the batch number and migration filenames. */
-const migrateLatest = async (config?: Knex.MigratorConfig): Promise<MigrationResult> => {
-	try {
-		const [batch, log] = await getDB().migrate.latest(resolveMigrationConfig(config))
-		return { batch, log }
-	} catch (error) {
-		throw toError(error)
-	}
-}
-
-/** Rolls back migrations. Set `all` to true to rollback all completed batches. */
-const migrateRollback = async (config?: Knex.MigratorConfig, all = false): Promise<MigrationResult> => {
-	try {
-		const [batch, log] = all
-			? await getDB().migrate.rollback(resolveMigrationConfig(config), true)
-			: await getDB().migrate.rollback(resolveMigrationConfig(config))
-		return { batch, log }
-	} catch (error) {
-		throw toError(error)
-	}
-}
-
-/** Returns the current migration version recorded by Knex. */
-const migrateCurrentVersion = async (config?: Knex.MigratorConfig): Promise<string> => {
-	try {
-		return await getDB().migrate.currentVersion(resolveMigrationConfig(config))
-	} catch (error) {
-		throw toError(error)
-	}
-}
-
-/** Returns completed and pending migration filenames. */
-const migrateList = async (config?: Knex.MigratorConfig): Promise<{ completed: string[]; pending: string[] }> => {
-	try {
-		const [completed, pending] = await getDB().migrate.list(resolveMigrationConfig(config))
-		const toName = (entry: unknown): string => {
-			if (typeof entry === 'string') {
-				return entry
-			}
-			if (entry && typeof entry === 'object') {
-				if ('name' in entry) {
-					return String((entry as { name: unknown }).name)
-				}
-				if ('file' in entry) {
-					return String((entry as { file: unknown }).file)
-				}
-			}
-			return String(entry)
-		}
-		return {
-			completed: completed.map(toName),
-			pending: pending.map(toName),
-		}
-	} catch (error) {
-		throw toError(error)
-	}
-}
-
-export {
-	DB,
-	getDB,
-	configure,
-	createKnexConfig,
-	configureDatabase,
-	setMigrationConfig,
-	getMigrationConfig,
-	makeMigration,
-	migrateLatest,
-	migrateRollback,
-	migrateCurrentVersion,
-	migrateList,
-}