@feathersjs/generators 5.0.28 → 5.0.29

package/lib/authentication/index.ts

@@ -1,119 +0,0 @@
-import chalk from 'chalk'
-import { dirname } from 'path'
-import { runGenerators, prompt } from '@featherscloud/pinion'
-import { fileURLToPath } from 'url'
-import {
-  addVersions,
-  checkPreconditions,
-  FeathersBaseContext,
-  initializeBaseContext,
-  install
-} from '../commons.js'
-import { generate as serviceGenerator, ServiceGeneratorContext } from '../service/index.js'
-
-// Set __dirname in es module
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-export interface AuthenticationGeneratorContext extends ServiceGeneratorContext {
-  service: string
-  entity: string
-  authStrategies: string[]
-  dependencies: string[]
-}
-
-export type AuthenticationGeneratorArguments = FeathersBaseContext &
-  Partial<Pick<AuthenticationGeneratorContext, 'service' | 'authStrategies' | 'path' | 'schema' | 'type'>>
-
-export const generate = (ctx: AuthenticationGeneratorArguments) =>
-  Promise.resolve(ctx)
-    .then(initializeBaseContext())
-    .then(checkPreconditions())
-    .then(
-      prompt((ctx: AuthenticationGeneratorArguments) => [
-        {
-          type: 'checkbox',
-          name: 'authStrategies',
-          when: !ctx.authStrategies,
-          message: 'Which authentication methods do you want to use?',
-          suffix: chalk.grey(' Other methods and providers can be added at any time.'),
-          choices: [
-            {
-              name: 'Email + Password',
-              value: 'local',
-              checked: true
-            },
-            {
-              name: 'Google',
-              value: 'google'
-            },
-            {
-              name: 'Facebook',
-              value: 'facebook'
-            },
-            {
-              name: 'Twitter',
-              value: 'twitter'
-            },
-            {
-              name: 'GitHub',
-              value: 'github'
-            },
-            {
-              name: 'Auth0',
-              value: 'auth0'
-            }
-          ]
-        },
-        {
-          name: 'service',
-          type: 'input',
-          when: !ctx.service,
-          message: 'What is your authentication service name?',
-          default: 'user'
-        },
-        {
-          name: 'path',
-          type: 'input',
-          when: !ctx.path,
-          message: 'What path should the service be registered on?',
-          default: 'users'
-        }
-      ])
-    )
-    .then(async (ctx) => {
-      const serviceContext = await serviceGenerator({
-        ...ctx,
-        name: ctx.service,
-        isEntityService: true
-      })
-
-      return {
-        ...ctx,
-        entity: ctx.service,
-        ...serviceContext
-      }
-    })
-    .then(runGenerators(__dirname, 'templates'))
-    .then((ctx) => ctx as AuthenticationGeneratorContext)
-    .then((ctx) => {
-      const dependencies: string[] = []
-
-      dependencies.push('@feathersjs/authentication-oauth')
-
-      if (ctx.authStrategies.includes('local')) {
-        dependencies.push('@feathersjs/authentication-local')
-      }
-
-      if (ctx.dependencies) {
-        return {
-          ...ctx,
-          dependencies: [...ctx.dependencies, ...dependencies]
-        }
-      }
-
-      return install<AuthenticationGeneratorContext>(
-        addVersions(dependencies, ctx.dependencyVersions),
-        false,
-        ctx.feathers.packager
-      )(ctx)
-    })

package/lib/authentication/templates/authentication.tpl.ts

@@ -1,52 +0,0 @@
-import { before, toFile } from '@featherscloud/pinion'
-import { injectSource, renderSource } from '../../commons.js'
-import { AuthenticationGeneratorContext } from '../index.js'
-import { localTemplate, oauthTemplate } from '../../commons.js'
-
-const template = ({
-  authStrategies
-}: AuthenticationGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/authentication.html
-import { AuthenticationService, JWTStrategy } from '@feathersjs/authentication'
-${localTemplate(authStrategies, `import { LocalStrategy } from '@feathersjs/authentication-local'`)}
-${oauthTemplate(authStrategies, `import { oauth, OAuthStrategy } from '@feathersjs/authentication-oauth'`)}
-
-import type { Application } from './declarations'
-
-declare module './declarations' {
-  interface ServiceTypes {
-    'authentication': AuthenticationService
-  }
-}
-
-export const authentication = (app: Application) => {
-  const authentication = new AuthenticationService(app)
-
-  authentication.register('jwt', new JWTStrategy())
-  ${authStrategies
-    .map(
-      (strategy) =>
-        `  authentication.register('${strategy}', ${
-          strategy === 'local' ? `new LocalStrategy()` : `new OAuthStrategy()`
-        })`
-    )
-    .join('\n')}
-
-  app.use('authentication', authentication)
-  ${oauthTemplate(authStrategies, `app.configure(oauth())`)}
-}
-`
-
-const importTemplate = "import { authentication } from './authentication'"
-const configureTemplate = 'app.configure(authentication)'
-const toAppFile = toFile<AuthenticationGeneratorContext>(({ lib }) => [lib, 'app'])
-
-export const generate = (ctx: AuthenticationGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(
-      renderSource(
-        template,
-        toFile<AuthenticationGeneratorContext>(({ lib }) => lib, 'authentication')
-      )
-    )
-    .then(injectSource(importTemplate, before('import { services } from'), toAppFile))
-    .then(injectSource(configureTemplate, before('app.configure(services)'), toAppFile))

package/lib/authentication/templates/client.test.tpl.ts

@@ -1,78 +0,0 @@
-import { toFile, when } from '@featherscloud/pinion'
-import { fileExists, renderSource } from '../../commons.js'
-import { AuthenticationGeneratorContext } from '../index.js'
-import { localTemplate } from '../../commons.js'
-
-const template = ({
-  authStrategies,
-  upperName,
-  type,
-  lib
-}: AuthenticationGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/client.test.html
-import assert from 'assert'
-import axios from 'axios'
-
-import rest from '@feathersjs/rest-client'
-${localTemplate(authStrategies, `import authenticationClient from '@feathersjs/authentication-client'`)}
-import { app } from '../${lib}/app'
-import { createClient } from '../${lib}/client' 
-${localTemplate(authStrategies, `import type { ${upperName}Data } from '../${lib}/client'`)}
-
-const port = app.get('port')
-const appUrl = \`http://\${app.get('host')}:\${port}\`
-
-describe('application client tests', () => {
-  const client = createClient(rest(appUrl).axios(axios))
-
-  before(async () => {
-    await app.listen(port)
-  })
-
-  after(async () => {
-    await app.teardown()
-  })
-
-  it('initialized the client', () => {
-    assert.ok(client)
-  })
-
-  ${localTemplate(
-    authStrategies,
-    `
-  it('creates and authenticates a user with email and password', async () => {
-    const userData: ${upperName}Data = {
-      email: 'someone@example.com',
-      password: 'supersecret'
-    }
-
-    await client.service('users').create(userData)
-    
-    const { user, accessToken } = await client.authenticate({
-      strategy: 'local',
-      ...userData
-    })
-    
-    assert.ok(accessToken, 'Created access token for user')
-    assert.ok(user, 'Includes user in authentication data')
-    assert.strictEqual(user.password, undefined, 'Password is hidden to clients')
-
-    await client.logout()
-
-    // Remove the test user on the server
-    await app.service('users').remove(user.${type === 'mongodb' ? '_id' : 'id'})
-  })`
-  )}
-})
-`
-
-export const generate = (ctx: AuthenticationGeneratorContext) =>
-  Promise.resolve(ctx).then(
-    when<AuthenticationGeneratorContext>(
-      ({ lib, language }) => fileExists(lib, `client.${language}`),
-      renderSource(
-        template,
-        toFile<AuthenticationGeneratorContext>(({ test }) => test, 'client.test'),
-        { force: true }
-      )
-    )
-  )

package/lib/authentication/templates/config.tpl.ts

@@ -1,60 +0,0 @@
-import crypto from 'crypto'
-import { toFile, mergeJSON } from '@featherscloud/pinion'
-import { AuthenticationGeneratorContext } from '../index.js'
-
-export const generate = (ctx: AuthenticationGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(
-      mergeJSON<AuthenticationGeneratorContext>(
-        ({ authStrategies }) => {
-          const authentication: any = {
-            entity: ctx.entity,
-            service: ctx.path,
-            secret: crypto.randomBytes(24).toString('base64'),
-            authStrategies: ['jwt'],
-            jwtOptions: {
-              header: {
-                typ: 'access'
-              },
-              audience: 'https://yourdomain.com',
-              algorithm: 'HS256',
-              expiresIn: '1d'
-            }
-          }
-
-          if (authStrategies.includes('local')) {
-            authentication.authStrategies.push('local')
-            authentication.local = {
-              usernameField: 'email',
-              passwordField: 'password'
-            }
-          }
-
-          const oauthStrategies = authStrategies.filter((name) => name !== 'local')
-
-          if (oauthStrategies.length) {
-            authentication.oauth = oauthStrategies.reduce((oauth, name) => {
-              oauth[name] = {
-                key: '<Client ID>',
-                secret: '<Client secret>'
-              }
-
-              return oauth
-            }, {} as any)
-          }
-
-          return { authentication }
-        },
-        toFile('config', 'default.json')
-      )
-    )
-    .then(
-      mergeJSON<AuthenticationGeneratorContext>(
-        {
-          authentication: {
-            secret: 'FEATHERS_SECRET'
-          }
-        },
-        toFile('config', 'custom-environment-variables.json')
-      )
-    )

package/lib/authentication/templates/declarations.tpl.ts

@@ -1,38 +0,0 @@
-import { inject, before, toFile, when, append } from '@featherscloud/pinion'
-import { AuthenticationGeneratorContext } from '../index.js'
-
-const importTemplate = ({
-  upperName,
-  folder,
-  fileName
-}: AuthenticationGeneratorContext) => /* ts */ `import { ${upperName} } from './services/${folder.join(
-  '/'
-)}/${fileName}'
-`
-
-const paramsTemplate = ({
-  entity,
-  upperName
-}: AuthenticationGeneratorContext) => /* ts */ `// Add the ${entity} as an optional property to all params
-declare module '@feathersjs/feathers' {
-  interface Params {
-    ${entity}?: ${upperName}
-  }
-}
-`
-
-const toDeclarationFile = toFile<AuthenticationGeneratorContext>(({ lib }) => lib, 'declarations.ts')
-
-export const generate = (ctx: AuthenticationGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(
-      when(
-        (ctx) => ctx.language === 'ts',
-        inject(
-          importTemplate,
-          before(/export \{ NextFunction \}|export type \{ NextFunction \}/),
-          toDeclarationFile
-        )
-      )
-    )
-    .then(when((ctx) => ctx.language === 'ts', inject(paramsTemplate, append(), toDeclarationFile)))

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 : ''