@radio-garden/ditojs-server 2.85.2-0.5067ad799

package/src/cli/db/createMigration.js

@@ -0,0 +1,241 @@
+import path from 'path'
+import fs from 'fs/promises'
+import pico from 'picocolors'
+import {
+  isObject,
+  isArray,
+  isString,
+  deindent,
+  capitalize
+} from '@ditojs/utils'
+import {
+  getRelationClass,
+  isThroughRelationClass
+} from '../../schema/relations.js'
+import { exists } from '../../utils/fs.js'
+
+const typeToKnex = {
+  number: 'double',
+  object: 'json',
+  array: 'json'
+}
+
+const defaultValues = {
+  'now()': `knex.raw('CURRENT_TIMESTAMP')`
+}
+
+export async function createMigration(app, name, ...modelNames) {
+  const migrationDir = path.join(app.basePath, 'migrations')
+  const models = modelNames.map(modelName => {
+    const modelClass = app.models[modelName]
+    if (!modelClass) {
+      throw new Error(`Model class with name '${modelName}' does not exist`)
+    }
+    return modelClass
+  })
+  const tables = []
+  for (const modelClass of models) {
+    collectModelTables(modelClass, app, tables)
+  }
+  for (const modelClass of models) {
+    collectThroughTables(modelClass, app, tables)
+  }
+  const createTables = []
+  const dropTables = []
+  for (const { tableName, statements } of tables) {
+    createTables.push(deindent`
+      .createTable('${tableName}', table => {
+        ${statements.join('\n')}
+      })`)
+    dropTables.unshift(deindent`
+      .dropTableIfExists('${tableName}')`)
+  }
+  const getCode = tables =>
+    tables.length > 0
+      ? deindent`
+      await knex.schema
+        ${tables.join('\n')}`
+      : ''
+  const filename = `${getTimestamp()}_${name}.js`
+  const file = path.join(migrationDir, filename)
+  if (await exists(file)) {
+    // This should never happen, but let's be on the safe side here:
+    console.info(pico.red(`Migration '${filename}' already exists.`))
+    return false
+  } else {
+    await fs.writeFile(
+      file,
+      deindent`
+        /** @param {import('knex').Knex} knex */
+        export async function up(knex) {
+          ${getCode(createTables)}
+        }
+
+        /** @param {import('knex').Knex} knex */
+        export async function down(knex) {
+          ${getCode(dropTables)}
+        }
+      `
+    )
+    console.info(pico.cyan(`Migration '${filename}' successfully created.`))
+    return true
+  }
+}
+
+async function collectModelTables(modelClass, app, tables) {
+  const tableName = app.normalizeIdentifier(modelClass.tableName)
+  const { properties, relations } = modelClass.definition
+  const statements = []
+  tables.push({ tableName, statements })
+  const uniqueComposites = {}
+  for (const [name, property] of Object.entries(properties)) {
+    const column = app.normalizeIdentifier(name)
+    let {
+      description,
+      type,
+      specificType,
+      unsigned,
+      computed,
+      nullable,
+      required,
+      primary,
+      foreign,
+      unique,
+      index,
+      default: _default
+    } = property
+    const knexType = typeToKnex[type] || type
+    if (!computed) {
+      if (description) {
+        statements.push(`// ${description.replace(/\s{2,}/g, ' ').trim()}`)
+      }
+      if (isString(unique)) {
+        // To declare composite foreign keys as unique, you can give each
+        // property the same string value in the `unique` keywords, e.g.:
+        // `unique: 'customerId_name'
+        const composites = (
+          uniqueComposites[unique] ||
+          (uniqueComposites[unique] = [])
+        )
+        composites.push(column)
+        unique = false
+      }
+      const statement = primary
+        ? [`table.increments('${column}').primary()`]
+        : specificType
+          ? [`table.specificType('${column}', '${specificType}')`]
+          : [`table.${knexType}('${column}')`]
+      statement.push(
+        unsigned && 'unsigned()',
+        !primary && required && 'notNullable()',
+        nullable && 'nullable()',
+        unique && 'unique()',
+        index && 'index()'
+      )
+      if (_default !== undefined) {
+        let value = defaultValues[_default]
+        if (!value) {
+          value =
+            isArray(_default) || isObject(_default)
+              ? JSON.stringify(_default)
+              : _default
+          if (isString(value)) {
+            value = `'${value}'`
+          }
+        }
+        statement.push(`defaultTo(${value})`)
+      }
+      if (foreign) {
+        for (const relation of Object.values(relations)) {
+          // TODO: Support composite keys for foreign references:
+          // Use `asArray(from)`, `asArray(to)`
+          const { from, to, owner } = relation
+          const [fromClass, fromProperty] = from?.split('.') || []
+          if (fromProperty === name) {
+            if (fromClass !== modelClass.name) {
+              throw Error(`Invalid relation declaration: ${relation}`)
+            }
+            const [toClass, toProperty] = to?.split('.') || []
+            statement.push(
+              '\n',
+              `references('${app.normalizeIdentifier(toProperty)}')`,
+              `inTable('${app.normalizeIdentifier(toClass)}')`,
+              // Only relations that aren't owners of their data should cascade
+              // on delete.
+              // TODO: Find the reverse relation of this in the other class and
+              // only add `onDelete('CASCADE')` if that one's an owner.
+              !owner && `onDelete('CASCADE')`
+            )
+          }
+        }
+      }
+      statements.push(
+        statement
+          .filter(str => !!str)
+          .join('.')
+          .replace(/\.\n\./g, '\n  .')
+      )
+    }
+  }
+  for (const composites of Object.values(uniqueComposites)) {
+    statements.push(
+      `table.unique([${
+        composites.map(column => `'${column}'`).join(', ')
+      }])`
+    )
+  }
+}
+
+async function collectThroughTables(modelClass, app, tables) {
+  const { relations } = modelClass.definition
+  for (const relation of Object.values(relations)) {
+    const { from, to, inverse } = relation
+    const relationClass = getRelationClass(relation.relation)
+    if (isThroughRelationClass(relationClass) && !inverse) {
+      // TODO: Support composite keys for foreign references:
+      // Use `asArray(from)`, `asArray(to)`
+      const [fromClass, fromProperty] = from?.split('.') || []
+      const [toClass, toProperty] = to?.split('.') || []
+      const statements = []
+      // See convertRelations()
+      const tableName = app.normalizeIdentifier(`${fromClass}${toClass}`)
+      const fromId = app.normalizeIdentifier(
+        `${fromClass}${capitalize(fromProperty)}`
+      )
+      const toId = app.normalizeIdentifier(
+        `${toClass}${capitalize(toProperty)}`
+      )
+      tables.push({ tableName, statements })
+      statements.push(`table.increments('id').primary()`)
+      statements.push(deindent`
+        table.integer('${fromId}').unsigned().index()
+          .references('${app.normalizeIdentifier(fromProperty)}')\\
+          .inTable('${app.normalizeIdentifier(fromClass)}')\\
+          .onDelete('CASCADE')`)
+      statements.push(deindent`
+        table.integer('${toId}').unsigned().index()
+          .references('${app.normalizeIdentifier(toProperty)}')\\
+          .inTable('${app.normalizeIdentifier(toClass)}')\\
+          .onDelete('CASCADE')`)
+    }
+  }
+}
+
+// Ensure that we have 2 places for each of the date segments.
+function padDate(segment) {
+  return segment.toString().padStart(2, '0')
+}
+
+// Get a date object in the correct format, without requiring a full out library
+// like "moment.js".
+function getTimestamp() {
+  const d = new Date()
+  return (
+    d.getFullYear().toString() +
+    padDate(d.getMonth() + 1) +
+    padDate(d.getDate()) +
+    padDate(d.getHours()) +
+    padDate(d.getMinutes()) +
+    padDate(d.getSeconds())
+  )
+}

package/src/cli/db/index.js

@@ -0,0 +1,7 @@
+export * from './createMigration.js'
+export * from './listAssetConfig.js'
+export * from './migrate.js'
+export * from './rollback.js'
+export * from './reset.js'
+export * from './seed.js'
+export * from './unlock.js'

package/src/cli/db/listAssetConfig.js

@@ -0,0 +1,10 @@
+import { formatJson } from '../../utils/json.js'
+
+export async function listAssetConfig(app, ...args) {
+  const assetConfig = app.getAssetConfig({
+    models: args.length > 0 ? args : Object.keys(app.models),
+    normalizeDbNames: true
+  })
+  console.info(formatJson(assetConfig))
+  return true
+}

package/src/cli/db/migrate.js

@@ -0,0 +1,12 @@
+import pico from 'picocolors'
+
+export async function migrate(knex) {
+  const [batch, log] = await knex.migrate.latest()
+  console.info(
+    log.length === 0
+      ? pico.cyan('Already up to date')
+      : pico.green(`Batch ${batch} run: ${log.length} migrations\n`) +
+        pico.cyan(log.join('\n'))
+  )
+  return true
+}

package/src/cli/db/reset.js

@@ -0,0 +1,23 @@
+import pico from 'picocolors'
+import { migrate } from './migrate.js'
+
+export async function reset(knex) {
+  const batches = []
+  const migrations = []
+  while (true) {
+    const [batch, log] = await knex.migrate.rollback()
+    if (log.length === 0) break
+    batches.push(batch)
+    migrations.push(...log)
+  }
+  console.info(
+    migrations.length === 0
+      ? pico.cyan('Already at the base migration')
+      : pico.green(
+          `${batches.length > 1 ? 'Batches' : 'Batch'} ${batches} ` +
+          `rolled back: ${migrations.length} migrations\n`
+        ) + pico.cyan(migrations.join('\n'))
+  )
+  await migrate(knex)
+  return true
+}

package/src/cli/db/rollback.js

@@ -0,0 +1,12 @@
+import pico from 'picocolors'
+
+export async function rollback(knex) {
+  const [batch, log] = await knex.migrate.rollback()
+  console.info(
+    log.length === 0
+      ? pico.cyan('Already at the base migration')
+      : pico.green(`Batch ${batch} rolled back: ${log.length} migrations\n`) +
+        pico.cyan(log.join('\n'))
+  )
+  return true
+}

package/src/cli/db/seed.js

@@ -0,0 +1,80 @@
+import path from 'path'
+import fs from 'fs/promises'
+import pico from 'picocolors'
+import util from 'util'
+import pluralize from 'pluralize'
+import { isFunction, isArray, camelize } from '@ditojs/utils'
+
+export async function seed(app) {
+  const seedDir = path.join(app.basePath, 'seeds')
+  const files = await fs.readdir(seedDir)
+  const seeds = []
+  // Create a lookup table with sort indices per model name.
+  const modelIndices = Object.keys(app.models).reduce(
+    (indices, name, index) => {
+      indices[name] = index
+      return indices
+    },
+    {}
+  )
+  // Collect all seed, and separate between seed functions and model see data:
+  for (const file of files) {
+    const { name, ext, base } = path.parse(file)
+    if (!name.startsWith('.') && ['.js', '.json'].includes(ext)) {
+      const object = await import(path.resolve(seedDir, file))
+      const seed = object.default || object
+      // Try to determine the related model from the seed name, and use it also
+      // to determine seed sequence based on its index in `app.models`.
+      const modelClass = (
+        app.models[name] ||
+        app.models[camelize(pluralize.singular(name), true)]
+      )
+      const index = modelClass ? modelIndices[modelClass.name] : Infinity
+      seeds.push({
+        base,
+        seed,
+        modelClass,
+        index
+      })
+    }
+  }
+  // Now sort the seed model data according to `app.models` sorting,
+  // as determined by `Application.sortModels()`:
+  seeds.sort((entry1, entry2) => entry1.index - entry2.index)
+  for (const { base, seed, modelClass } of seeds) {
+    await handleSeed(app, base, seed, modelClass)
+  }
+  return true
+}
+
+async function handleSeed(app, base, seed, modelClass) {
+  try {
+    let res
+    if (isFunction(seed)) {
+      res = await seed(app.models)
+    } else if (modelClass) {
+      await modelClass.truncate({ cascade: true })
+      res = await modelClass.insertGraph(seed)
+    }
+    if (isArray(res)) {
+      console.info(
+        pico.green(`${base}:`),
+        pico.cyan(`${res.length} seed records created.`)
+      )
+    } else {
+      console.info(
+        pico.red(`${base}:`),
+        pico.cyan('No seed records created.')
+      )
+    }
+  } catch (err) {
+    console.error(
+      pico.red(`${base}:`),
+      util.inspect(err, {
+        colors: true,
+        depth: null,
+        maxArrayLength: null
+      })
+    )
+  }
+}

package/src/cli/db/unlock.js

@@ -0,0 +1,9 @@
+import pico from 'picocolors'
+
+export async function unlock(knex) {
+  await knex.migrate.forceFreeMigrationsLock()
+  console.info(
+    pico.green(`Successfully unlocked the migrations lock table`)
+  )
+  return true
+}

package/src/cli/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import path from 'path'
+import fs from 'fs'
+import pico from 'picocolors'
+import Knex from 'knex'
+import { isPlainObject, isFunction, camelize } from '@ditojs/utils'
+import * as db from './db/index.js'
+import startConsole from './console.js'
+
+const commands = { db, console: startConsole }
+
+function getCommand(commands, parts) {
+  const part = parts.shift()
+  return commands && part
+    ? getCommand(commands[camelize(part)], parts)
+    : commands
+}
+
+function setSilent(silent) {
+  const wasSilent = process.env.DITO_SILENT
+  process.env.DITO_SILENT = silent
+  return wasSilent
+}
+
+async function execute() {
+  try {
+    // Dynamically load app or config from the path provided package.json script
+    const [, , command, importPath, ...args] = process.argv
+    const execute = command && getCommand(commands, command.split(':'))
+    if (!isFunction(execute)) {
+      throw new Error(`Unknown command: ${command}`)
+    }
+    const silent = setSilent(true)
+    let arg
+    try {
+      arg = (await import(path.resolve(importPath))).default
+    } finally {
+      setSilent(silent)
+    }
+    if (isFunction(arg)) {
+      arg = await arg()
+    }
+    if (isPlainObject(arg) && arg.knex) {
+      // A config object with a knex field was passed in, create a knex object
+      // from it to pass on to the execute function.
+      arg = Knex(arg.knex)
+    }
+    const res = await execute(arg, ...args)
+    process.exit(res === true ? 0 : 1)
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(
+        pico.red(`${err.detail ? `${err.detail}\n` : ''}${err.stack}`)
+      )
+    } else {
+      console.error(pico.red(err))
+    }
+    process.exit(1)
+  }
+}
+
+// Start the console if `node ./cli/index.js`
+
+// See module was not imported but called directly
+const path1 = fs.realpathSync(import.meta.url.replace(/^file:\/\//, ''))
+const path2 = fs.realpathSync(process.argv[1])
+if (path1 === path2) {
+  execute()
+}
+
+export default execute