@feathersjs/generators 5.0.28 → 5.0.30

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

package/lib/service/templates/schema.json.tpl.ts

@@ -1,143 +0,0 @@
-import { toFile, when } from '@featherscloud/pinion'
-import { fileExists, localTemplate, renderSource } from '../../commons.js'
-import { ServiceGeneratorContext } from '../index.js'
-
-const authFieldsTemplate = (authStrategies: string[]) =>
-  authStrategies
-    .map((name) =>
-      name === 'local'
-        ? `    email: { type: 'string' },
-    password: { type: 'string' }`
-        : `    ${name}Id: { type: 'string' }`
-    )
-    .join(',\n')
-
-const template = ({
-  camelName,
-  upperName,
-  fileName,
-  relative,
-  authStrategies,
-  isEntityService,
-  type,
-  cwd,
-  lib
-}: ServiceGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/service.schemas.html
-import { resolve, getValidator, querySyntax } from '@feathersjs/schema'${
-  type === 'mongodb'
-    ? `
-import { ObjectIdSchema } from '@feathersjs/schema'`
-    : ''
-}
-import type { FromSchema } from '@feathersjs/schema'
-${localTemplate(authStrategies, `import { passwordHash } from '@feathersjs/authentication-local'`)}
-
-import type { HookContext } from '${relative}/declarations'
-import { dataValidator, queryValidator } from '${relative}/${
-  fileExists(cwd, lib, 'schemas') ? 'schemas/' : '' // This is for legacy backwards compatibility
-}validators'
-import type { ${upperName}Service } from './${fileName}.class'
-
-// Main data model schema
-export const ${camelName}Schema = {
-  $id: '${upperName}',
-  type: 'object',
-  additionalProperties: false,
-  required: [ '${type === 'mongodb' ? '_id' : 'id'}', ${localTemplate(authStrategies, `'email'`, `'text'`)} ],
-  properties: {
-    ${type === 'mongodb' ? `_id: ObjectIdSchema(),` : `id: { type: 'number' },`}
-    ${
-      isEntityService
-        ? authFieldsTemplate(authStrategies)
-        : `
-    text: { type: 'string' }`
-    }
-  }
-} as const
-export type ${upperName} = FromSchema<typeof ${camelName}Schema>
-export const ${camelName}Validator = getValidator(${camelName}Schema, dataValidator)
-export const ${camelName}Resolver = resolve<${upperName}, HookContext<${upperName}Service>>({})
-
-export const ${camelName}ExternalResolver = resolve<${upperName}, HookContext<${upperName}Service>>({
-  ${localTemplate(
-    authStrategies,
-    `// The password should never be visible externally
-  password: async () => undefined`
-  )}
-})
-
-// Schema for creating new data
-export const ${camelName}DataSchema = {
-  $id: '${upperName}Data',
-  type: 'object',
-  additionalProperties: false,
-  required: [ ${localTemplate(authStrategies, `'email'`, `'text'`)} ],
-  properties: {
-    ...${camelName}Schema.properties
-  }
-} as const
-export type ${upperName}Data = FromSchema<typeof ${camelName}DataSchema>
-export const ${camelName}DataValidator = getValidator(${camelName}DataSchema, dataValidator)
-export const ${camelName}DataResolver = resolve<${upperName}Data, HookContext<${upperName}Service>>({
-  ${localTemplate(authStrategies, `password: passwordHash({ strategy: 'local' })`)}
-})
-
-// Schema for updating existing data
-export const ${camelName}PatchSchema = {
-  $id: '${upperName}Patch',
-  type: 'object',
-  additionalProperties: false,
-  required: [],
-  properties: {
-    ...${camelName}Schema.properties
-  }
-} as const
-export type ${upperName}Patch = FromSchema<typeof ${camelName}PatchSchema>
-export const ${camelName}PatchValidator = getValidator(${camelName}PatchSchema, dataValidator)
-export const ${camelName}PatchResolver = resolve<${upperName}Patch, HookContext<${upperName}Service>>({
-  ${localTemplate(authStrategies, `password: passwordHash({ strategy: 'local' })`)}
-})
-
-// Schema for allowed query properties
-export const ${camelName}QuerySchema = {
-  $id: '${upperName}Query',
-  type: 'object',
-  additionalProperties: false,
-  properties: {
-    ...querySyntax(${camelName}Schema.properties)
-  }
-} as const
-export type ${upperName}Query = FromSchema<typeof ${camelName}QuerySchema>
-export const ${camelName}QueryValidator = getValidator(${camelName}QuerySchema, queryValidator)
-export const ${camelName}QueryResolver = resolve<${upperName}Query, HookContext<${upperName}Service>>({
-  ${
-    isEntityService
-      ? `
-  // If there is a user (e.g. with authentication), they are only allowed to see their own data
-  ${type === 'mongodb' ? '_id' : 'id'}: async (value, user, context) => {
-    if (context.params.user) {
-      return context.params.user.${type === 'mongodb' ? '_id' : 'id'}
-    }
-
-    return value
-  }`
-      : ''
-  }
-})
-`
-
-export const generate = (ctx: ServiceGeneratorContext) =>
-  Promise.resolve(ctx).then(
-    when<ServiceGeneratorContext>(
-      ({ schema }) => schema === 'json',
-      renderSource(
-        template,
-        toFile(({ lib, folder, fileName }: ServiceGeneratorContext) => [
-          lib,
-          'services',
-          ...folder,
-          `${fileName}.schema`
-        ])
-      )
-    )
-  )

package/lib/service/templates/schema.typebox.tpl.ts

@@ -1,131 +0,0 @@
-import { toFile, when } from '@featherscloud/pinion'
-import { fileExists, localTemplate, renderSource } from '../../commons.js'
-import { ServiceGeneratorContext } from '../index.js'
-
-const authFieldsTemplate = (authStrategies: string[]) =>
-  authStrategies
-    .map((name) =>
-      name === 'local'
-        ? `  email: Type.String(),
-  password: Type.Optional(Type.String())`
-        : `  ${name}Id: Type.Optional(Type.String())`
-    )
-    .join(',\n')
-
-const template = ({
-  camelName,
-  upperName,
-  fileName,
-  relative,
-  authStrategies,
-  isEntityService,
-  type,
-  cwd,
-  lib
-}: ServiceGeneratorContext) => /* ts */ `// // For more information about this file see https://dove.feathersjs.com/guides/cli/service.schemas.html
-import { resolve } from '@feathersjs/schema'
-import { Type, getValidator, querySyntax } from '@feathersjs/typebox'${
-  type === 'mongodb'
-    ? `
-import { ObjectIdSchema } from '@feathersjs/typebox'`
-    : ''
-}
-import type { Static } from '@feathersjs/typebox'
-${localTemplate(authStrategies, `import { passwordHash } from '@feathersjs/authentication-local'`)}
-
-import type { HookContext } from '${relative}/declarations'
-import { dataValidator, queryValidator } from '${relative}/${
-  fileExists(cwd, lib, 'schemas') ? 'schemas/' : '' // This is for legacy backwards compatibility
-}validators'
-import type { ${upperName}Service } from './${fileName}.class'
-
-// Main data model schema
-export const ${camelName}Schema = Type.Object({
-    ${type === 'mongodb' ? '_id: ObjectIdSchema()' : 'id: Type.Number()'},
-    ${isEntityService ? authFieldsTemplate(authStrategies) : `text: Type.String()`}
-  }, { $id: '${upperName}', additionalProperties: false })
-export type ${upperName} = Static<typeof ${camelName}Schema>
-export const ${camelName}Validator = getValidator(${camelName}Schema, dataValidator)
-export const ${camelName}Resolver = resolve<${upperName}, HookContext<${upperName}Service>>({})
-
-export const ${camelName}ExternalResolver = resolve<${upperName}, HookContext<${upperName}Service>>({
-  ${localTemplate(
-    authStrategies,
-    `// The password should never be visible externally
-  password: async () => undefined`
-  )}  
-})
-
-// Schema for creating new entries
-export const ${camelName}DataSchema = Type.Pick(${camelName}Schema, [
-  ${
-    isEntityService
-      ? authStrategies.map((name) => (name === 'local' ? `'email', 'password'` : `'${name}Id'`)).join(', ')
-      : `'text'`
-  }
-], {
-  $id: '${upperName}Data'
-})
-export type ${upperName}Data = Static<typeof ${camelName}DataSchema>
-export const ${camelName}DataValidator = getValidator(${camelName}DataSchema, dataValidator)
-export const ${camelName}DataResolver = resolve<${upperName}, HookContext<${upperName}Service>>({
-  ${localTemplate(authStrategies, `password: passwordHash({ strategy: 'local' })`)}
-})
-
-// Schema for updating existing entries
-export const ${camelName}PatchSchema = Type.Partial(${camelName}Schema, {
-  $id: '${upperName}Patch'
-})
-export type ${upperName}Patch = Static<typeof ${camelName}PatchSchema>
-export const ${camelName}PatchValidator = getValidator(${camelName}PatchSchema, dataValidator)
-export const ${camelName}PatchResolver = resolve<${upperName}, HookContext<${upperName}Service>>({
-  ${localTemplate(authStrategies, `password: passwordHash({ strategy: 'local' })`)}
-})
-
-// Schema for allowed query properties
-export const ${camelName}QueryProperties = Type.Pick(${camelName}Schema, [
-  '${type === 'mongodb' ? '_id' : 'id'}', ${
-    isEntityService
-      ? authStrategies.map((name) => (name === 'local' ? `'email'` : `'${name}Id'`)).join(', ')
-      : `'text'`
-  }
-])
-export const ${camelName}QuerySchema = Type.Intersect([
-  querySyntax(${camelName}QueryProperties),
-  // Add additional query properties here
-  Type.Object({}, { additionalProperties: false })
-], { additionalProperties: false })
-export type ${upperName}Query = Static<typeof ${camelName}QuerySchema>
-export const ${camelName}QueryValidator = getValidator(${camelName}QuerySchema, queryValidator)
-export const ${camelName}QueryResolver = resolve<${upperName}Query, HookContext<${upperName}Service>>({
-  ${
-    isEntityService
-      ? `
-  // If there is a user (e.g. with authentication), they are only allowed to see their own data
-  ${type === 'mongodb' ? '_id' : 'id'}: async (value, user, context) => {
-    if (context.params.user) {
-      return context.params.user.${type === 'mongodb' ? '_id' : 'id'}
-    }
-
-    return value
-  }`
-      : ''
-  }
-})
-`
-
-export const generate = (ctx: ServiceGeneratorContext) =>
-  Promise.resolve(ctx).then(
-    when<ServiceGeneratorContext>(
-      ({ schema }) => schema === 'typebox',
-      renderSource(
-        template,
-        toFile(({ lib, folder, fileName }: ServiceGeneratorContext) => [
-          lib,
-          'services',
-          ...folder,
-          `${fileName}.schema`
-        ])
-      )
-    )
-  )

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

@@ -1,161 +0,0 @@
-import { toFile, after, prepend } from '@featherscloud/pinion'
-import { fileExists, injectSource, renderSource } from '../../commons.js'
-import { ServiceGeneratorContext } from '../index.js'
-
-export const template = ({
-  camelName,
-  authentication,
-  isEntityService,
-  path,
-  lib,
-  language,
-  className,
-  relative,
-  schema,
-  fileName
-}: ServiceGeneratorContext) => /* ts */ `// For more information about this file see https://dove.feathersjs.com/guides/cli/service.html
-${authentication || isEntityService ? `import { authenticate } from '@feathersjs/authentication'` : ''}
-${
-  schema
-    ? `
-import { hooks as schemaHooks } from '@feathersjs/schema'
-    
-import {
-  ${camelName}DataValidator,
-  ${camelName}PatchValidator,
-  ${camelName}QueryValidator,
-  ${camelName}Resolver,
-  ${camelName}ExternalResolver,
-  ${camelName}DataResolver,
-  ${camelName}PatchResolver,
-  ${camelName}QueryResolver
-} from './${fileName}.schema'
-`
-    : ''
-}
-
-import type { Application } from '${relative}/declarations'
-import { ${className}, getOptions } from './${fileName}.class'
-${
-  fileExists(lib, `client.${language}`)
-    ? `import { ${camelName}Path, ${camelName}Methods } from './${fileName}.shared'`
-    : `
-export const ${camelName}Path = '${path}'
-export const ${camelName}Methods: Array<keyof ${className}> = ['find', 'get', 'create', 'patch', 'remove']`
-}
-
-export * from './${fileName}.class'
-${schema ? `export * from './${fileName}.schema'` : ''}
-
-// A configure function that registers the service and its hooks via \`app.configure\`
-export const ${camelName} = (app: Application) => {
-  // Register our service on the Feathers application
-  app.use(${camelName}Path, new ${className}(getOptions(app)), {
-    // A list of all methods this service exposes externally
-    methods: ${camelName}Methods,
-    // You can add additional custom events to be sent to clients here
-    events: []
-  })
-  // Initialize hooks
-  app.service(${camelName}Path).hooks({
-    around: {
-      all: [${
-        authentication
-          ? `
-        authenticate('jwt'),`
-          : ''
-      } ${
-        schema
-          ? `
-        schemaHooks.resolveExternal(${camelName}ExternalResolver),
-        schemaHooks.resolveResult(${camelName}Resolver),`
-          : ''
-      }
-      ],${
-        isEntityService
-          ? `
-      find: [authenticate('jwt')],
-      get: [authenticate('jwt')],
-      create: [],
-      update: [authenticate('jwt')],
-      patch: [authenticate('jwt')],
-      remove: [authenticate('jwt')]`
-          : ''
-      }
-    },
-    before: {
-      all: [${
-        schema
-          ? `
-        schemaHooks.validateQuery(${camelName}QueryValidator),
-        schemaHooks.resolveQuery(${camelName}QueryResolver)
-      `
-          : ''
-      }],
-      find: [],
-      get: [],
-      create: [${
-        schema
-          ? `
-        schemaHooks.validateData(${camelName}DataValidator),
-        schemaHooks.resolveData(${camelName}DataResolver)
-      `
-          : ''
-      }],
-      patch: [${
-        schema
-          ? `
-        schemaHooks.validateData(${camelName}PatchValidator),
-        schemaHooks.resolveData(${camelName}PatchResolver)
-      `
-          : ''
-      }],
-      remove: []
-    },
-    after: {
-      all: []
-    },
-    error: {
-      all: []
-    }
-  })
-}
-
-// Add this service to the service type index
-declare module '${relative}/declarations' {
-  interface ServiceTypes {
-    [${camelName}Path]: ${className}
-  }
-}
-`
-
-const toServiceIndex = toFile(({ lib }: ServiceGeneratorContext) => [lib, 'services', `index`])
-
-export const generate = (ctx: ServiceGeneratorContext) =>
-  Promise.resolve(ctx)
-    .then(
-      renderSource(
-        template,
-        toFile(({ lib, fileName, folder }: ServiceGeneratorContext) => [
-          lib,
-          'services',
-          ...folder,
-          `${fileName}`
-        ])
-      )
-    )
-    .then(
-      injectSource<ServiceGeneratorContext>(
-        ({ camelName, folder, fileName }) =>
-          `import { ${camelName} } from './${folder.join('/')}/${fileName}'`,
-        prepend(),
-        toServiceIndex
-      )
-    )
-    .then(
-      injectSource<ServiceGeneratorContext>(
-        ({ camelName }) => `  app.configure(${camelName})`,
-        after('export const services'),
-        toServiceIndex
-      )
-    )