@feathersjs/generators 5.0.28 → 5.0.29

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])
-    )
-  )

package/lib/index.ts

@@ -1,8 +0,0 @@
-export * from '@featherscloud/pinion'
-
-export * from './commons.js'
-export * as app from './app/index.js'
-export * as authentication from './authentication/index.js'
-export * as connection from './connection/index.js'
-export * as hook from './hook/index.js'
-export * as service from './service/index.js'

package/lib/service/index.ts

@@ -1,214 +0,0 @@
-import { dirname } from 'path'
-import _ from 'lodash'
-import { runGenerator, runGenerators, prompt } from '@featherscloud/pinion'
-import { fileURLToPath } from 'url'
-import chalk from 'chalk'
-
-import {
-  checkPreconditions,
-  DATABASE_TYPES,
-  FeathersBaseContext,
-  fileExists,
-  getDatabaseAdapter,
-  initializeBaseContext
-} from '../commons.js'
-
-// Set __dirname in es module
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export interface ServiceGeneratorContext extends FeathersBaseContext {
-  /**
-   * The chosen service name
-   */
-  name: string
-  /**
-   * The path the service is registered on
-   */
-  path: string
-  /**
-   * The list of subfolders this service is in
-   */
-  folder: string[]
-  /**
-   * The `camelCase` service name starting with a lowercase letter
-   */
-  camelName: string
-  /**
-   * The `CamelCase` service name starting with an uppercase letter
-   */
-  upperName: string
-  /**
-   * The service class name combined as `CamelCaseService`
-   */
-  className: string
-  /**
-   * A kebab-cased (filename friendly) version of the service name
-   */
-  kebabName: string
-  /**
-   * The actual filename (the last element of the path)
-   */
-  fileName: string
-  /**
-   * The kebab-cased name of the path. Will be used for e.g. database names
-   */
-  kebabPath: string
-  /**
-   * Indicates how many file paths we should go up to import other things (e.g. `../../`)
-   */
-  relative: string
-  /**
-   * The chosen service type
-   */
-  type: 'knex' | 'mongodb' | 'custom'
-  /**
-   * Which schema definition format to use
-   */
-  schema: 'typebox' | 'json' | false
-  /**
-   * Wether this service uses authentication
-   */
-  authentication: boolean
-  /**
-   * Set to true if this service is for an authentication entity
-   */
-  isEntityService?: boolean
-  /**
-   * The authentication strategies (if it is an entity service)
-   */
-  authStrategies: string[]
-}
-
-/**
- * Parameters the generator is called with
- */
-export type ServiceGeneratorArguments = FeathersBaseContext &
-  Partial<
-    Pick<ServiceGeneratorContext, 'name' | 'path' | 'type' | 'authentication' | 'isEntityService' | 'schema'>
-  >
-
-export const generate = (ctx: ServiceGeneratorArguments) =>
-  Promise.resolve(ctx)
-    .then(initializeBaseContext())
-    .then(checkPreconditions())
-    .then(
-      prompt(({ name, path, type, schema, authentication, isEntityService, feathers, lib, language }) => {
-        const sqlDisabled = DATABASE_TYPES.every(
-          (name) => name === 'mongodb' || name === 'other' || !fileExists(lib, `${name}.${language}`)
-        )
-        const mongodbDisabled = !fileExists(lib, `mongodb.${language}`)
-
-        return [
-          {
-            name: 'name',
-            type: 'input',
-            when: !name,
-            message: 'What is the name of your service?',
-            validate: (input: any) => {
-              if (!input || input === 'authentication') {
-                return 'Invalid service name'
-              }
-
-              return true
-            }
-          },
-          {
-            name: 'path',
-            type: 'input',
-            when: !path,
-            message: 'Which path should the service be registered on?',
-            default: (answers: ServiceGeneratorArguments) => `${_.kebabCase(answers.name)}`,
-            validate: (input: any) => {
-              if (!input || input === 'authentication') {
-                return 'Invalid service path'
-              }
-
-              return true
-            }
-          },
-          {
-            name: 'authentication',
-            type: 'confirm',
-            when: authentication === undefined && !isEntityService,
-            message: 'Does this service require authentication?'
-          },
-          {
-            name: 'type',
-            type: 'list',
-            when: !type,
-            message: 'What database is the service using?',
-            default: getDatabaseAdapter(feathers?.database),
-            choices: [
-              {
-                value: 'knex',
-                name: `SQL${sqlDisabled ? chalk.gray(' (connection not available)') : ''}`,
-                disabled: sqlDisabled
-              },
-              {
-                value: 'mongodb',
-                name: `MongoDB${mongodbDisabled ? chalk.gray(' (connection not available)') : ''}`,
-                disabled: mongodbDisabled
-              },
-              {
-                value: 'custom',
-                name: 'A custom service'
-              }
-            ]
-          },
-          {
-            name: 'schema',
-            type: 'list',
-            when: schema === undefined,
-            message: 'Which schema definition format do you want to use?',
-            suffix: chalk.grey(' Schemas allow to type, validate, secure and populate data'),
-            default: feathers?.schema,
-            choices: (answers: ServiceGeneratorContext) => [
-              {
-                value: 'typebox',
-                name: `TypeBox ${chalk.gray(' (recommended)')}`
-              },
-              {
-                value: 'json',
-                name: 'JSON schema'
-              },
-              {
-                value: false,
-                name: `No schema${
-                  answers.type !== 'custom' ? chalk.gray(' (not recommended with a database)') : ''
-                }`
-              }
-            ]
-          }
-        ]
-      })
-    )
-    .then(async (ctx): Promise<ServiceGeneratorContext> => {
-      const { name, path, type, authStrategies = [] } = ctx as any as ServiceGeneratorContext
-      const kebabName = _.kebabCase(name)
-      const camelName = _.camelCase(name)
-      const upperName = _.upperFirst(camelName)
-      const className = `${upperName}Service`
-
-      const folder = path.split('/').filter((el) => el !== '')
-      const relative = ['', ...folder].map(() => '..').join('/')
-      const fileName = _.last(folder)
-      const kebabPath = _.kebabCase(path)
-
-      return {
-        name,
-        type,
-        path,
-        folder,
-        fileName,
-        upperName,
-        className,
-        kebabName,
-        camelName,
-        kebabPath,
-        relative,
-        authStrategies,
-        ...ctx
-      } as ServiceGeneratorContext
-    })
-    .then(runGenerators<ServiceGeneratorContext>(__dirname, 'templates'))
-    .then(runGenerator<ServiceGeneratorContext>(__dirname, 'type', ({ type }) => `${type}.tpl.js`))

package/lib/service/templates/client.tpl.ts

@@ -1,33 +0,0 @@
-import { toFile, after, before, when } from '@featherscloud/pinion'
-import { fileExists, injectSource } from '../../commons.js'
-import { ServiceGeneratorContext } from '../index.js'
-
-const importTemplate = ({ upperName, folder, fileName, camelName }: ServiceGeneratorContext) => /* ts */ `
-import { ${camelName}Client } from './services/${folder.join('/')}/${fileName}.shared'
-export type {
-  ${upperName},
-  ${upperName}Data,
-  ${upperName}Query,
-  ${upperName}Patch
-} from './services/${folder.join('/')}/${fileName}.shared'
-`
-
-const registrationTemplate = ({ camelName }: ServiceGeneratorContext) =>
-  `  client.configure(${camelName}Client)`
-
-const toClientFile = toFile<ServiceGeneratorContext>(({ lib }) => [lib, 'client'])
-
-export const generate = async (ctx: ServiceGeneratorContext) =>
-  Promise.resolve(ctx).then(
-    when<ServiceGeneratorContext>(
-      ({ lib, language }) => fileExists(lib, `client.${language}`),
-      injectSource(registrationTemplate, before('return client'), toClientFile),
-      injectSource(
-        importTemplate,
-        after<ServiceGeneratorContext>(({ language }) =>
-          language === 'ts' ? 'import type { AuthenticationClientOptions }' : 'import authenticationClient'
-        ),
-        toClientFile
-      )
-    )
-  )