@h3ravel/arquebus 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 arquebus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+<div align="center">
+  <img src="https://h3ravel.toneflix.net/logo-full.svg" width="100" alt="H3ravel logo" />
+  <h1 align="center"><a href="https://h3ravel.toneflix.net/arquebus">H3ravel Arquebus</a></h1>
+  <a href="https://www.npmjs.com/package/@h3ravel/arquebus"><img alt="NPM version" src="https://img.shields.io/npm/v/@h3ravel/arquebus.svg"></a>
+  <a href="https://github.com/h3ravel/arquebus/workflows/tests"><img alt="ci" src="https://github.com/h3ravel/arquebus/workflows/tests/badge.svg"></a>
+  <a href="https://github.com/h3ravel/arquebus/blob/main/README.md"><img alt="GitHub" src="https://img.shields.io/github/license/h3ravel/arquebus"></a>
+  <br />
+</div>
+
+Arquebus ORM is a Beautiful, expressive framework-agnostic Object-Relational Mapper (ORM) inspired by Laravel's Eloquent, designed for TypeScript applications and for the H3ravel Framework that makes it enjoyable to interact with your database. When using Arquebus, each database table has a corresponding "Model" that is used to interact with that table. In addition to retrieving records from the database table, Arquebus models allow you to insert, update, and delete records from the database as well.
+
+> Arquebus is a Typescript and Modern JS rewrite of [Sutando](https://sutando.org/) and is heavily inspired by Laravel's ORM [Eloquent](https://laravel.com/docs/12.x/eloquent).
+
+## ✨ Features
+
+- Supports MySQL, PostgreSQL, SQLite and other databases
+- Concise syntax and intuitive operations
+- Model relationships for handling complex data queries and operations
+- Powerful query builder
+- Customized data type conversion for model attributes
+- Easy-to-use transaction
+- Support for hooks to execute custom logic at different stages of model operations
+- Simple plugin mechanism for easy expansion
+
+## Documentation
+
+Check the full documentation on [https://h3ravel.toneflix.net/arquebus](https://h3ravel.toneflix.net/arquebus)
+
+## Quick Start
+
+Let’s take mysql as an example.
+
+Install Arquebus and mysql database library
+
+```sh
+$ npm install @h3ravel/arquebus mysql2 --save
+```
+
+The easiest way to make SQL queries is to use the Database query builder. It allows you to construct simple and complex SQL queries using JavaScript methods.
+
+```ts
+import { arquebus, Model } from '@h3ravel/arquebus';
+
+// Add SQL Connection Info
+arquebus.addConnection({
+  client: 'mysql2',
+  connection: {
+    host: '127.0.0.1',
+    port: 3306,
+    user: 'root',
+    password: '',
+    database: 'test',
+  },
+});
+
+const db = arquebus.connection();
+
+// Query Builder
+const users = await db.table('users').where('age', '>', 35).get();
+
+// ORM
+class User extends Model {}
+
+// Query Data
+const users = await User.query().where('age', '>', 35).get();
+
+// Insert
+const user = new User();
+user.name = 'David Bowie';
+await user.save();
+
+// Delete
+await user.delete();
+
+// Pagination
+const users = await User.query().paginate();
+
+// Eager Loading
+const users = await User.query().with('posts').get();
+
+// Constraining Eager Loads
+const users = await User.query()
+  .with({
+    posts: (q) => q.where('likes_count', '>', 100),
+  })
+  .get();
+
+// Lazy Eager Loading
+await user.load('posts');
+```
+
+## Show Your Support
+
+Please ⭐️ this repository if this project helped you

package/bin/cli.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import { program } from 'commander'
+import path from 'path'
+import { promisify } from 'util'
+import fs from 'fs'
+import * as color from 'colorette'
+import resolveFrom from 'resolve-from'
+import { snake } from 'radashi'
+import { success, exit, twoColumnDetail, findUpConfig, findUpModulePath, findModulePkg, TableGuesser, localModuleCheck } from './utils.js'
+import cliPkg from '../package.json' with { type: 'json' }
+
+const writeFile = promisify(fs.writeFile)
+const readFile = promisify(fs.readFile)
+
+const env = {
+  modulePath: findModulePkg('arquebus') || resolveFrom.silent(process.cwd(), 'arquebus') || findUpModulePath(process.cwd(), 'arquebus'),
+  cwd: process.cwd(),
+  configPath: findUpConfig(process.cwd(), 'arquebus.config', ['js', 'cjs'])
+}
+let modulePackage = {}
+try {
+  modulePackage = require(path.join(env.modulePath, 'package.json'))
+}
+catch {
+  /* empty */
+}
+function getArquebusModule (modulePath) {
+  localModuleCheck(env)
+}
+const cliVersion = [
+  'Arquebus CLI version:',
+  color.green(cliPkg.version),
+].join(' ')
+const localVersion = [
+  'Arquebus Local version:',
+  color.green(modulePackage.version || 'None'),
+].join(' ')
+program
+  .name('arquebus')
+  .version(`${cliVersion}\n${localVersion}`)
+program
+  .command('init')
+  .description('Create a fresh arquebus config.')
+  .action(async () => {
+    localModuleCheck(env)
+    const type = 'js'
+    if (env.configPath) {
+      exit(`Error: ${env.configPath} already exists`)
+    }
+    try {
+      const stubPath = `./arquebus.config.${type}`
+      const code = await readFile(env.modulePath +
+        '/src/stubs/arquebus.config-' +
+        type +
+        '.stub')
+      await writeFile(stubPath, code)
+      success(color.green(`Created ${stubPath}`))
+    }
+    catch (e) {
+      exit(e)
+    }
+  })
+program
+  .command('migrate:make <name>')
+  .description('Create a new migration file.')
+  .option('--table', 'The table to migrate')
+  .option('--create', 'The table to be created')
+  .action(async (name, opts) => {
+    if (!env.configPath) {
+      exit('Error: arquebus config not found. Run `arquebus init` first.')
+    }
+    try {
+      name = snake(name)
+      let table = opts.table
+      let create = opts.create || false
+      if (!table && typeof create === 'string') {
+        table = create
+        create = true
+      }
+      if (!table) {
+        const guessed = TableGuesser.guess(name)
+        table = guessed[0]
+        create = guessed[1]
+      }
+      const MigrationCreator = getArquebusModule('src/migrations/migration-creator')
+      const creator = new MigrationCreator('')
+      const fileName = await creator.create(name, env.cwd + `/${config?.migrations?.path || 'migrations'}`, table, create)
+      success(color.green(`Created Migration: ${fileName}`))
+    }
+    catch (err) {
+      exit(err)
+    }
+  })
+program
+  .command('migrate:publish <package>')
+  .description('Publish any migration files from packages.')
+  .action(async (pkg, opts) => {
+    if (!env.configPath) {
+      exit('Error: arquebus config not found. Run `arquebus init` first.')
+    }
+    try {
+      const packagePath = findModulePkg(pkg)
+      if (!packagePath) {
+        exit(`Error: package ${pkg} not found`)
+      }
+      const MigrationCreator = getArquebusModule('src/migrations/migration-creator')
+      const creator = new MigrationCreator(path.join(packagePath, 'migrations'))
+      console.log(color.green('Publishing migrations:'))
+      const fileNames = await creator.publish(env.cwd + `/${config?.migrations?.path || 'migrations'}`, (fileName, oldPath, newPath) => {
+        console.log(newPath + ' ' + color.green('DONE'))
+      })
+    }
+    catch (err) {
+      exit(err)
+    }
+  })
+program
+  .command('migrate:run')
+  .description('Run all pending migrations.')
+  .option('--step', 'Force the migrations to be run so they can be rolled back individually.')
+  .option('--path <path>', 'The path to the migrations directory.')
+  .action(async (opts) => {
+    if (!env.configPath) {
+      exit('Error: arquebus config not found. Run `arquebus init` first.')
+    }
+    try {
+      const { migrateRun } = getArquebusModule('src/migrate')
+      await migrateRun(config, opts, true)
+    }
+    catch (err) {
+      exit(err)
+    }
+  })
+program
+  .command('migrate:rollback')
+  .description('Rollback the last database migration.')
+  .option('--step <number>', 'The number of migrations to be reverted.')
+  .option('--path <path>', 'The path to the migrations directory.')
+  .action(async (opts) => {
+    if (!env.configPath) {
+      exit('Error: arquebus config not found. Run `arquebus init` first.')
+    }
+    try {
+      const { migrateRollback } = getArquebusModule('src/migrate')
+      await migrateRollback(config, opts, true)
+    }
+    catch (err) {
+      exit(err)
+    }
+  })
+program
+  .command('migrate:status')
+  .description('Show the status of each migration.')
+  .option('--path <path>', 'The path to the migrations directory.')
+  .action(async (opts) => {
+    if (!env.configPath) {
+      exit('Error: arquebus config not found. Run `arquebus init` first.')
+    }
+    try {
+      const { migrateStatus } = getArquebusModule('src/migrate')
+      const migrations = await migrateStatus(config, opts, true)
+      if (migrations.length > 0) {
+        twoColumnDetail(color.gray('Migration name'), color.gray('Batch / Status'))
+        migrations.forEach(migration => {
+          const status = migration.ran
+            ? `[${migration.batch}] ${color.green('Ran')}`
+            : color.yellow('Pending')
+          twoColumnDetail(migration.name, status)
+        })
+      }
+      else {
+        console.log('No migrations found')
+      }
+    }
+    catch (err) {
+      exit(err)
+    }
+  })
+program
+  .command('model:make <name>')
+  .description('Create a new Model file.')
+  .option('--force', 'Force creation if model already exists.', false)
+  .action(async (name, opts) => {
+    if (!env.configPath) {
+      exit('Error: arquebus config not found. Run `arquebus init` first.')
+    }
+    try {
+      const modelPath = path.join(env.cwd, config?.models?.path || 'models', name?.toLowerCase() + '.js')
+      if (!opts.force && fs.existsSync(modelPath)) {
+        exit('Model already exists.')
+      }
+      await promisify(fs.mkdir)(path.dirname(modelPath), { recursive: true })
+      const stubPath = path.join(env.modulePath, 'src/stubs/model-js.stub')
+      let stub = await readFile(stubPath, 'utf-8')
+      stub = stub.replace(/{{ name }}/g, name)
+      await writeFile(modelPath, stub)
+      success(color.green(`Created Model: ${modelPath}`))
+    }
+    catch (err) {
+      exit(err)
+    }
+  })
+program.parse()

package/bin/utils.js

@@ -0,0 +1,141 @@
+import * as color from 'colorette'
+
+import escalade from 'escalade/sync'
+import path from 'path'
+import resolveFrom from 'resolve-from'
+
+function success (text) {
+  console.log(text)
+  process.exit(0)
+}
+
+function exit (text) {
+  if (text instanceof Error) {
+    if (text.message) {
+      console.error(color.red(text.message))
+    }
+    console.error(color.red(`${text.detail ? `${text.detail}\n` : ''}${text.stack}`))
+  }
+  else {
+    console.error(color.red(text))
+  }
+  process.exit(1)
+}
+
+function twoColumnDetail (name, value) {
+  const regex = /\x1b\[\d+m/g
+  const width = Math.min(process.stdout.columns, 100)
+  const dots = Math.max(width - name.replace(regex, '').length - value.replace(regex, '').length - 10, 0)
+  return console.log(name, color.gray('.'.repeat(dots)), value)
+}
+
+function findUpConfig (cwd, name, extensions) {
+  return escalade(cwd, (dir, names) => {
+    for (const ext of extensions) {
+      const filename = `${name}.${ext}`
+      if (names.includes(filename)) {
+        return filename
+      }
+    }
+    return false
+  })
+}
+
+function findUpModulePath (cwd, packageName) {
+  const modulePackagePath = escalade(cwd, (dir, names) => {
+    if (names.includes('package.json')) {
+      return 'package.json'
+    }
+    return false
+  })
+  try {
+    if (modulePackage.name === packageName) {
+      return path.join(path.dirname(modulePackagePath), modulePackage.main || 'index.js')
+    }
+  }
+  catch (e) {
+    /* empty */
+  }
+}
+
+function findModulePkg (moduleId, options = {}) {
+  const parts = moduleId.replace(/\\/g, '/').split('/')
+  let packageName = ''
+  // Handle scoped package name
+  if (parts.length > 0 && parts[0][0] === '@') {
+    packageName += parts.shift() + '/'
+  }
+  packageName += parts.shift()
+  const packageJson = path.join(packageName, 'package.json')
+  const resolved = resolveFrom.silent(options.cwd || process.cwd(), packageJson)
+  if (!resolved) {
+    return
+  }
+  return path.join(path.dirname(resolved), parts.join('/'))
+}
+
+const join = path.join
+
+async function getMigrationPaths (cwd, migrator, defaultPath, path) {
+  if (path) {
+    return [join(cwd, path)]
+  }
+  return [
+    ...migrator.getPaths(),
+    join(cwd, defaultPath),
+  ]
+}
+
+function localModuleCheck (env) {
+  if (!env.modulePath) {
+    console.log(color.red('No local arquebus install found.'))
+    exit('Try running: npm install arquebus --save')
+  }
+}
+class TableGuesser {
+  static CREATE_PATTERNS = [
+    /^create_(\w+)_table$/,
+    /^create_(\w+)$/
+  ]
+  static CHANGE_PATTERNS = [
+    /.+_(to|from|in)_(\w+)_table$/,
+    /.+_(to|from|in)_(\w+)$/
+  ]
+  static guess (migration) {
+    for (const pattern of TableGuesser.CREATE_PATTERNS) {
+      const matches = migration.match(pattern)
+      if (matches) {
+        return [matches[1], true]
+      }
+    }
+    for (const pattern of TableGuesser.CHANGE_PATTERNS) {
+      const matches = migration.match(pattern)
+      if (matches) {
+        return [matches[2], false]
+      }
+    }
+    return []
+  }
+}
+
+export { exit }
+export { success }
+export { twoColumnDetail }
+export { findUpModulePath }
+export { findModulePkg }
+export { findUpConfig }
+export { localModuleCheck }
+export { getMigrationPaths }
+export { TableGuesser }
+
+export default {
+  exit,
+  success,
+  twoColumnDetail,
+  findUpModulePath,
+  findModulePkg,
+  findUpConfig,
+  localModuleCheck,
+  getMigrationPaths,
+  TableGuesser
+}