@feathersjs/generators 5.0.28 → 5.0.30

package/lib/commons.ts

@@ -1,346 +0,0 @@
-import fs from 'fs'
-import { join, dirname } from 'path'
-import { PackageJson } from 'type-fest'
-import { readFile, writeFile } from 'fs/promises'
-import {
-  Callable,
-  PinionContext,
-  loadJSON,
-  fromFile,
-  getCallable,
-  renderTemplate,
-  inject,
-  Location,
-  exec
-} from '@featherscloud/pinion'
-import ts from 'typescript'
-import prettier, { Options as PrettierOptions } from 'prettier'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-// Set __dirname in es module
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export const { version } = JSON.parse(fs.readFileSync(join(__dirname, '..', 'package.json')).toString())
-
-export type DependencyVersions = { [key: string]: string }
-
-export const DATABASE_TYPES = ['mongodb', 'mysql', 'postgresql', 'sqlite', 'mssql', 'other'] as const
-
-/**
- * The database types supported by this generator
- */
-export type DatabaseType = (typeof DATABASE_TYPES)[number]
-
-/**
- * Returns the name of the Feathers database adapter for a supported database type
- *
- * @param database The type of the database
- * @returns The name of the adapter
- */
-export const getDatabaseAdapter = (database: DatabaseType) => (database === 'mongodb' ? 'mongodb' : 'knex')
-
-export type FeathersAppInfo = {
-  /**
-   * The application language
-   */
-  language: 'ts' | 'js'
-  /**
-   * The main database
-   */
-  database: DatabaseType
-  /**
-   * The package manager used
-   */
-  packager: 'yarn' | 'npm' | 'pnpm'
-  /**
-   * A list of all chosen transports
-   */
-  transports: ('rest' | 'websockets')[]
-  /**
-   * The HTTP framework used
-   */
-  framework: 'koa' | 'express'
-  /**
-   * The main schema definition format
-   */
-  schema: 'typebox' | 'json' | false
-}
-
-export interface AppPackageJson extends PackageJson {
-  feathers?: FeathersAppInfo
-}
-
-export interface FeathersBaseContext extends PinionContext {
-  /**
-   * Information about the Feathers application (like chosen language, database etc.)
-   * usually taken from `package.json`
-   */
-  feathers: FeathersAppInfo
-  /**
-   * The package.json file
-   */
-  pkg: AppPackageJson
-  /**
-   * The folder where source files are put
-   */
-  lib: string
-  /**
-   * The folder where test files are put
-   */
-  test: string
-  /**
-   * The language the app is generated in
-   */
-  language: 'js' | 'ts'
-  /**
-   * A list dependencies that should be installed with a certain version.
-   * Used for installing development dependencies during testing.
-   */
-  dependencyVersions?: DependencyVersions
-}
-
-/**
- * Returns dependencies with the versions from the context attached (if available)
- *
- * @param dependencies The dependencies to install
- * @param versions The dependency version list
- * @returns A list of dependencies with their versions
- */
-export const addVersions = (dependencies: string[], versions: DependencyVersions) =>
-  dependencies.map((dep) => `${dep}@${versions[dep] ? versions[dep] : 'latest'}`)
-
-/**
- * Loads the application package.json and populates information like the library and test directory
- * and Feathers app specific information.
- *
- * @returns The updated context
- */
-export const initializeBaseContext =
-  () =>
-  <C extends FeathersBaseContext>(ctx: C) =>
-    Promise.resolve(ctx)
-      .then(loadJSON(fromFile('package.json'), (pkg) => ({ pkg }), {}))
-      .then(
-        loadJSON(path.join(__dirname, '..', 'package.json'), (pkg: PackageJson) => ({
-          dependencyVersions: {
-            ...pkg.devDependencies,
-            ...ctx.dependencyVersions,
-            '@feathersjs/cli': version
-          }
-        }))
-      )
-      .then((ctx) => ({
-        ...ctx,
-        lib: ctx.pkg?.directories?.lib || 'src',
-        test: ctx.pkg?.directories?.test || 'test',
-        language: ctx.language || ctx.pkg?.feathers?.language,
-        feathers: ctx.pkg?.feathers
-      }))
-
-/**
- * Checks if the current context contains a valid generated application. This is necesary for most
- * generators (besides the app generator).
- *
- * @param ctx The context to check against
- * @returns Throws an error or returns the original context
- */
-export const checkPreconditions =
-  () =>
-  async <T extends FeathersBaseContext>(ctx: T) => {
-    if (!ctx.feathers) {
-      throw new Error(`Can not run generator since the current folder does not appear to be a Feathers application.
-Either your package.json is missing or it does not have \`feathers\` property.
-`)
-    }
-
-    return ctx
-  }
-
-const importRegex = /from '(\..*)'/g
-const escapeNewLines = (code: string) => code.replace(/\n\n/g, '\n/* :newline: */')
-const restoreNewLines = (code: string) => code.replace(/\/\* :newline: \*\//g, '\n')
-const fixLocalImports = (code: string) => code.replace(importRegex, "from '$1.js'")
-
-/**
- * Returns the transpiled and prettified JavaScript for a TypeScript source code
- *
- * @param typescript The TypeScript source code
- * @param options TypeScript transpilation options
- * @returns The formatted JavaScript source code
- */
-export const getJavaScript = (typescript: string, options: ts.TranspileOptions = {}) => {
-  const source = escapeNewLines(typescript)
-  const transpiled = ts.transpileModule(source, {
-    ...options,
-    compilerOptions: {
-      module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2020,
-      preserveValueImports: true,
-      ...options.compilerOptions
-    }
-  })
-  const { outputText } = transpiled
-
-  if (outputText.startsWith('export {}') && typescript.startsWith('import')) {
-    return fixLocalImports(typescript)
-  }
-
-  return fixLocalImports(restoreNewLines(transpiled.outputText))
-}
-
-const getFileName = async <C extends PinionContext & { language: 'js' | 'ts' }>(
-  target: Callable<string, C>,
-  ctx: C
-) => `${await getCallable(target, ctx)}.${ctx.language}`
-
-/**
- * The default configuration for prettifying files
- */
-export const PRETTIERRC: PrettierOptions = {
-  tabWidth: 2,
-  useTabs: false,
-  printWidth: 110,
-  semi: false,
-  trailingComma: 'none',
-  singleQuote: true
-}
-
-/*
- * Format a source file using Prettier. Will use the local configuration, the settings set in
- * `options` or a default configuration
- *
- * @param target The file to prettify
- * @param options The Prettier options
- * @returns The updated context
- */
-export const prettify =
-  <C extends PinionContext & { language: 'js' | 'ts' }>(
-    target: Callable<string, C>,
-    options: PrettierOptions = PRETTIERRC
-  ) =>
-  async (ctx: C) => {
-    const fileName = await getFileName(target, ctx)
-    const config = (await prettier.resolveConfig(ctx.cwd)) || options
-    const content = (await readFile(fileName)).toString()
-
-    try {
-      await writeFile(
-        fileName,
-        await prettier.format(content, {
-          parser: ctx.language === 'ts' ? 'typescript' : 'babel',
-          ...config
-        })
-      )
-    } catch (error: any) {
-      throw new Error(`Error prettifying ${fileName}: ${error.message}`)
-    }
-
-    return ctx
-  }
-
-/**
- * Render a source file template for the language set in the context.
- *
- * @param templates The JavaScript and TypeScript template to render
- * @param target The target filename without extension (will be added based on language)
- * @returns The updated context
- */
-export const renderSource =
-  <C extends PinionContext & { language: 'js' | 'ts' }>(
-    template: Callable<string, C>,
-    target: Callable<string, C>,
-    options?: { force: boolean }
-  ) =>
-  async (ctx: C) => {
-    const { language } = ctx
-    const fileName = await getFileName(target, ctx)
-    const content = language === 'js' ? getJavaScript(await getCallable<string, C>(template, ctx)) : template
-    const renderer = renderTemplate(content, fileName, options)
-
-    return renderer(ctx).then(prettify(target))
-  }
-
-export const install =
-  <C extends PinionContext & { language: 'js' | 'ts' }>(
-    dependencies: Callable<string[], C>,
-    dev: Callable<boolean, C>,
-    packager: Callable<string, C>
-  ) =>
-  async (ctx: C) => {
-    const dependencyList = await getCallable(dependencies, ctx)
-    const packageManager = await getCallable(packager, ctx)
-    const flags = dev ? [packageManager === 'yarn' ? '--dev' : '--save-dev'] : []
-
-    return exec(packager, [packageManager === 'yarn' ? 'add' : 'install', ...dependencyList, ...flags])(ctx)
-  }
-
-/**
- * Inject a source template as the language set in the context.
- *
- * @param template The source template to render
- * @param location The location to inject the code to. Must use the target language.
- * @param target The target file name
- * @param transpile Set to `false` if the code should not be transpiled to JavaScript
- * @returns
- */
-export const injectSource =
-  <C extends PinionContext & { language: 'js' | 'ts' }>(
-    template: Callable<string, C>,
-    location: Location<C>,
-    target: Callable<string, C>,
-    transpile = true
-  ) =>
-  async (ctx: C) => {
-    const { language } = ctx
-    const source =
-      language === 'js' && transpile ? getJavaScript(await getCallable<string, C>(template, ctx)) : template
-    const fileName = await getFileName(target, ctx)
-    const injector = inject(source, location, fileName)
-
-    return injector(ctx).then(prettify(target))
-  }
-
-/**
- * Synchronously checks if a file exits
- * @param context The base context
- * @param filenames The filenames to check
- * @returns Wether the file exists or not
- */
-export const fileExists = (...filenames: string[]) => fs.existsSync(join(...filenames))
-
-/**
- * The helper used by Knex to create migration names
- * @returns The current date and time in the format `YYYYMMDDHHMMSS`
- */
-export const yyyymmddhhmmss = (offset = 0) => {
-  const now = new Date(Date.now() + offset)
-
-  return (
-    now.getUTCFullYear().toString() +
-    (now.getUTCMonth() + 1).toString().padStart(2, '0') +
-    now.getUTCDate().toString().padStart(2, '0') +
-    now.getUTCHours().toString().padStart(2, '0') +
-    now.getUTCMinutes().toString().padStart(2, '0') +
-    now.getUTCSeconds().toString().padStart(2, '0')
-  )
-}
-
-/**
- * Render a template if `local` authentication strategy has been selected
- * @param authStrategies The list of selected authentication strategies
- * @param content The content to render if `local` is selected
- * @param alt The content to render if `local` is not selected
- * @returns
- */
-export const localTemplate = (authStrategies: string[], content: string, alt = '') =>
-  authStrategies.includes('local') ? content : alt
-
-/**
- * Render a template if an `oauth` authentication strategy has been selected
- * @param authStrategies
- * @param content
- * @returns
- */
-export const oauthTemplate = (authStrategies: string[], content: string) =>
-  authStrategies.filter((s) => s !== 'local').length > 0 ? content : ''

package/lib/connection/index.ts

@@ -1,138 +0,0 @@
-import { dirname } from 'path'
-import { runGenerator, prompt, mergeJSON, toFile, when } from '@featherscloud/pinion'
-import { fileURLToPath } from 'url'
-import chalk from 'chalk'
-import {
-  install,
-  FeathersBaseContext,
-  DatabaseType,
-  getDatabaseAdapter,
-  addVersions,
-  checkPreconditions,
-  initializeBaseContext
-} from '../commons.js'
-
-// Set __dirname in es module
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export interface ConnectionGeneratorContext extends FeathersBaseContext {
-  name?: string
-  database: DatabaseType
-  connectionString: string
-  dependencies: string[]
-}
-
-export type ConnectionGeneratorArguments = FeathersBaseContext &
-  Partial<Pick<ConnectionGeneratorContext, 'database' | 'connectionString' | 'name'>>
-
-export const defaultConnectionString = (type: DatabaseType, name: string) => {
-  const connectionStrings = {
-    mongodb: `mongodb://127.0.0.1:27017/${name}`,
-    mysql: `mysql://root:@localhost:3306/${name}`,
-    postgresql: `postgres://postgres:@localhost:5432/${name}`,
-    sqlite: `${name}.sqlite`,
-    mssql: `mssql://root:password@localhost:1433/${name}`,
-    other: ''
-  }
-
-  return connectionStrings[type]
-}
-
-export const prompts = ({ database, connectionString, pkg, name }: ConnectionGeneratorArguments) => [
-  {
-    name: 'database',
-    type: 'list',
-    when: !database,
-    message: 'Which database are you connecting to?',
-    suffix: chalk.grey(' Databases can be added at any time'),
-    choices: [
-      { value: 'sqlite', name: 'SQLite' },
-      { value: 'mongodb', name: 'MongoDB' },
-      { value: 'postgresql', name: 'PostgreSQL' },
-      { value: 'mysql', name: 'MySQL/MariaDB' },
-      { value: 'mssql', name: 'Microsoft SQL' },
-      {
-        value: 'other',
-        name: `Another database ${chalk.grey('(not configured automatically, use with custom services)')}`
-      }
-    ]
-  },
-  {
-    name: 'connectionString',
-    type: 'input',
-    when: (answers: ConnectionGeneratorContext) =>
-      !connectionString && database !== 'other' && answers.database !== 'other',
-    message: 'Enter your database connection string',
-    default: (answers: ConnectionGeneratorContext) =>
-      defaultConnectionString(answers.database, answers.name || name || pkg.name)
-  }
-]
-
-export const DATABASE_CLIENTS = {
-  mongodb: 'mongodb',
-  sqlite: 'sqlite3',
-  postgresql: 'pg',
-  mysql: 'mysql',
-  mssql: 'mssql'
-}
-
-export const getDatabaseClient = (database: DatabaseType) =>
-  database === 'other' ? null : DATABASE_CLIENTS[database]
-
-export const generate = (ctx: ConnectionGeneratorArguments) =>
-  Promise.resolve(ctx)
-    .then(initializeBaseContext())
-    .then(checkPreconditions())
-    .then(prompt(prompts))
-    .then((ctx) => ctx as ConnectionGeneratorContext)
-    .then(
-      when<ConnectionGeneratorContext>(
-        (ctx) => ctx.database !== 'other',
-        runGenerator<ConnectionGeneratorContext>(
-          __dirname,
-          'templates',
-          ({ database }) => `${getDatabaseAdapter(database)}.tpl.js`
-        ),
-        mergeJSON<ConnectionGeneratorContext>(
-          ({ connectionString, database }) =>
-            getDatabaseAdapter(database) === 'knex'
-              ? {
-                  [database]: {
-                    client: getDatabaseClient(database),
-                    connection: connectionString,
-                    ...(database === 'sqlite' ? { useNullAsDefault: true } : {})
-                  }
-                }
-              : {
-                  [database]: connectionString
-                },
-          toFile('config', 'default.json')
-        ),
-        async (ctx: ConnectionGeneratorContext) => {
-          const dependencies: string[] = []
-          const adapter = getDatabaseAdapter(ctx.database)
-          const dbClient = getDatabaseClient(ctx.database)
-
-          dependencies.push(`@feathersjs/${adapter}`)
-
-          if (adapter === 'knex') {
-            dependencies.push('knex')
-          }
-
-          dependencies.push(dbClient)
-
-          if (ctx.dependencies) {
-            return {
-              ...ctx,
-              dependencies: [...ctx.dependencies, ...dependencies]
-            }
-          }
-
-          return install<ConnectionGeneratorContext>(
-            addVersions(dependencies, ctx.dependencyVersions),
-            false,
-            ctx.feathers.packager
-          )(ctx)
-        }
-      )
-    )

package/lib/connection/templates/knex.tpl.ts

@@ -1,73 +0,0 @@
-import { toFile, before, mergeJSON } from '@featherscloud/pinion'
-import { ConnectionGeneratorContext } from '../index.js'
-import { injectSource, renderSource } from '../../commons.js'
-import { mkdir } from 'fs/promises'
-import path from 'path'
-
-const template = ({
-  database
-}: ConnectionGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/databases.html
-import knex from 'knex'
-import type { Knex } from 'knex'
-import type { Application } from './declarations'
-
-declare module './declarations' {
-  interface Configuration {
-    ${database}Client: Knex
-  }
-}
-
-export const ${database} = (app: Application) => {
-  const config = app.get('${database}')
-  const db = knex(config!)
-
-  app.set('${database}Client', db)
-}
-`
-
-const knexfile = ({
-  lib,
-  language,
-  database
-}: ConnectionGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/databases.html
-import { app } from './${lib}/app'
-
-// Load our database connection info from the app configuration
-const config = app.get('${database}')
-
-${language === 'js' ? 'export default config' : 'module.exports = config'}
-`
-
-const importTemplate = ({ database }: ConnectionGeneratorContext) =>
-  `import { ${database} } from './${database}'`
-const configureTemplate = ({ database }: ConnectionGeneratorContext) => `app.configure(${database})`
-
-const toAppFile = toFile<ConnectionGeneratorContext>(({ lib }) => [lib, 'app'])
-
-export const generate = (ctx: ConnectionGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(
-      renderSource(
-        template,
-        toFile<ConnectionGeneratorContext>(({ lib, database }) => [lib, database])
-      )
-    )
-    .then(renderSource(knexfile, toFile('knexfile')))
-    .then(
-      mergeJSON<ConnectionGeneratorContext>(
-        (ctx) => ({
-          scripts: {
-            migrate: 'knex migrate:latest',
-            'migrate:make': 'knex migrate:make' + (ctx.language === 'js' ? ' -x mjs' : ''),
-            test: 'cross-env NODE_ENV=test npm run migrate && npm run mocha'
-          }
-        }),
-        toFile('package.json')
-      )
-    )
-    .then(injectSource(importTemplate, before('import { services } from'), toAppFile))
-    .then(injectSource(configureTemplate, before('app.configure(services)'), toAppFile))
-    .then(async (ctx) => {
-      await mkdir(path.join(ctx.cwd, 'migrations'))
-      return ctx
-    })

package/lib/connection/templates/mongodb.tpl.ts

@@ -1,50 +0,0 @@
-import { toFile, before, prepend, append } from '@featherscloud/pinion'
-import { ConnectionGeneratorContext } from '../index.js'
-import { injectSource, renderSource } from '../../commons.js'
-
-const template = ({
-  database
-}: ConnectionGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/databases.html
-import { MongoClient } from 'mongodb'
-import type { Db } from 'mongodb'
-import type { Application } from './declarations'
-
-declare module './declarations' {
-  interface Configuration {
-    ${database}Client: Promise<Db>
-  }
-}
-
-export const ${database} = (app: Application) => {
-  const connection = app.get('${database}') as string
-  const database = new URL(connection).pathname.substring(1)
-  const mongoClient = MongoClient.connect(connection)
-    .then(client => client.db(database))
-
-  app.set('${database}Client', mongoClient)
-}
-`
-
-const keywordImport = `import { keywordObjectId } from '@feathersjs/mongodb'`
-
-const keywordTemplate = `dataValidator.addKeyword(keywordObjectId)
-queryValidator.addKeyword(keywordObjectId)`
-
-const importTemplate = ({ database }: ConnectionGeneratorContext) =>
-  `import { ${database} } from './${database}'`
-const configureTemplate = ({ database }: ConnectionGeneratorContext) => `app.configure(${database})`
-const toAppFile = toFile<ConnectionGeneratorContext>(({ lib }) => [lib, 'app'])
-const toValidatorFile = toFile<ConnectionGeneratorContext>(({ lib }) => [lib, 'validators'])
-
-export const generate = (ctx: ConnectionGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(
-      renderSource(
-        template,
-        toFile<ConnectionGeneratorContext>(({ lib, database }) => [lib, database])
-      )
-    )
-    .then(injectSource(importTemplate, before('import { services } from'), toAppFile))
-    .then(injectSource(configureTemplate, before('app.configure(services)'), toAppFile))
-    .then(injectSource(keywordImport, prepend(), toValidatorFile))
-    .then(injectSource(keywordTemplate, append(), toValidatorFile))

package/lib/hook/index.ts

@@ -1,52 +0,0 @@
-import { dirname } from 'path'
-import { fileURLToPath } from 'url'
-import { prompt, runGenerators } from '@featherscloud/pinion'
-import _ from 'lodash'
-import { checkPreconditions, FeathersBaseContext, initializeBaseContext } from '../commons.js'
-
-// Set __dirname in es module
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export interface HookGeneratorContext extends FeathersBaseContext {
-  name: string
-  camelName: string
-  kebabName: string
-  type: 'regular' | 'around'
-}
-
-export const generate = (ctx: HookGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(initializeBaseContext())
-    .then(checkPreconditions())
-    .then(
-      prompt<HookGeneratorContext>(({ type, name }) => [
-        {
-          type: 'input',
-          name: 'name',
-          message: 'What is the name of the hook?',
-          when: !name
-        },
-        {
-          name: 'type',
-          type: 'list',
-          when: !type,
-          message: 'What kind of hook is it?',
-          choices: [
-            { value: 'around', name: 'Around' },
-            { value: 'regular', name: 'Before, After or Error' }
-          ]
-        }
-      ])
-    )
-    .then((ctx) => {
-      const { name } = ctx
-      const kebabName = _.kebabCase(name)
-      const camelName = _.camelCase(name)
-
-      return {
-        ...ctx,
-        kebabName,
-        camelName
-      }
-    })
-    .then(runGenerators(__dirname, 'templates'))

package/lib/hook/templates/hook.tpl.ts

@@ -1,33 +0,0 @@
-import { toFile } from '@featherscloud/pinion'
-import { HookGeneratorContext } from '../index.js'
-import { renderSource } from '../../commons.js'
-
-const aroundTemplate = ({
-  camelName,
-  name
-}: HookGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/hook.html
-import type { HookContext, NextFunction } from '../declarations'
-
-export const ${camelName} = async (context: HookContext, next: NextFunction) => {
-  console.log(\`Running hook ${name} on \${context.path}\.\${context.method}\`)
-  await next()
-}
-`
-
-const regularTemplate = ({
-  camelName,
-  name
-}: HookGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/hook.html
-import type { HookContext } from '../declarations'
-
-export const ${camelName} = async (context: HookContext) => {
-  console.log(\`Running hook ${name} on \${context.path}\.\${context.method}\`)
-}`
-
-export const generate = (ctx: HookGeneratorContext) =>
-  Promise.resolve(ctx).then(
-    renderSource(
-      (ctx) => (ctx.type === 'around' ? aroundTemplate(ctx) : regularTemplate(ctx)),
-      toFile<HookGeneratorContext>(({ lib, kebabName }) => [lib, 'hooks', kebabName])
-    )
-  )