@adonisjs/core 6.1.5-3 → 6.1.5-30

package/modules/hash/define_config.ts

@@ -1,64 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import { InvalidArgumentsException } from '@poppinss/utils'
-
-import driversCollection from './drivers_collection.js'
-import type { HashDriversList } from '../../src/types.js'
-import type { ManagerDriverFactory } from '../../types/hash.js'
-
-/**
- * Define config for the hash service.
- */
-export function defineConfig<
-  KnownHashers extends Record<
-    string,
-    {
-      [K in keyof HashDriversList]: { driver: K } & Parameters<HashDriversList[K]>[0]
-    }[keyof HashDriversList]
-  >
->(config: {
-  default?: keyof KnownHashers
-  list: KnownHashers
-}): {
-  default?: keyof KnownHashers
-  list: { [K in keyof KnownHashers]: ManagerDriverFactory }
-} {
-  /**
-   * Hashers list should always be provided
-   */
-  if (!config.list) {
-    throw new InvalidArgumentsException('Missing "list" property in hash config')
-  }
-
-  /**
-   * The default hasher should be mentioned in the list
-   */
-  if (config.default && !config.list[config.default]) {
-    throw new InvalidArgumentsException(
-      `Missing "list.${String(
-        config.default
-      )}" in hash config. It is referenced by the "default" property`
-    )
-  }
-
-  /**
-   * Converting list config to a collection that hash manager can use
-   */
-  const managerHashers = Object.keys(config.list).reduce((result, disk: keyof KnownHashers) => {
-    const hasherConfig = config.list[disk]
-    result[disk] = () => driversCollection.create(hasherConfig.driver, hasherConfig)
-    return result
-  }, {} as { [K in keyof KnownHashers]: ManagerDriverFactory })
-
-  return {
-    default: config.default,
-    list: managerHashers,
-  }
-}

package/modules/hash/drivers_collection.ts

@@ -1,61 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-/**
- * This class exists in the core, because it maintains a list of
- * globally available drivers applicable to the hash manager
- * instance registered with the container.
- *
- * In other words, these drivers are not needed by the hash module
- * regular usage and specific to AdonisJS container flow.
- */
-
-import { RuntimeException } from '@poppinss/utils'
-import type { HashDriversList } from '../../src/types.js'
-
-/**
- * A global collection of Hash drivers
- */
-class HashDriversCollection {
-  /**
-   * List of registered drivers
-   */
-  list: Partial<HashDriversList> = {}
-
-  /**
-   * Extend drivers collection and add a custom
-   * driver to it.
-   */
-  extend<Name extends keyof HashDriversList>(
-    driverName: Name,
-    factoryCallback: HashDriversList[Name]
-  ): this {
-    this.list[driverName] = factoryCallback
-    return this
-  }
-
-  /**
-   * Creates the driver instance with config
-   */
-  create<Name extends keyof HashDriversList>(
-    name: Name,
-    config: Parameters<HashDriversList[Name]>[0]
-  ) {
-    const driverFactory = this.list[name]
-    if (!driverFactory) {
-      throw new RuntimeException(
-        `Unknown hash driver "${String(name)}". Make sure the driver is registered`
-      )
-    }
-
-    return driverFactory(config as any)
-  }
-}
-
-export default new HashDriversCollection()

package/modules/hash/main.ts

@@ -1,12 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-export * from '@adonisjs/hash'
-export { defineConfig } from './define_config.js'
-export { default as driversList } from './drivers_collection.js'

package/modules/http.ts

@@ -1,10 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-export * from '@adonisjs/http-server'

package/modules/logger.ts

@@ -1,10 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-export * from '@adonisjs/logger'

package/providers/app_provider.ts

@@ -1,125 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import { Config } from '../modules/config.js'
-import { Logger } from '../modules/logger.js'
-import { validator } from '../legacy/validator.js'
-import { Encryption } from '../modules/encryption.js'
-import type { ApplicationService, LoggerService } from '../src/types.js'
-
-/**
- * The Application Service provider registers all the baseline
- * features required to run the framework.
- */
-export default class AppServiceProvider {
-  constructor(protected app: ApplicationService) {}
-
-  /**
-   * Registers test utils with the container
-   */
-  protected registerTestUtils() {
-    this.app.container.singleton('testUtils', async () => {
-      const { TestUtils } = await import('../src/test_utils/main.js')
-      return new TestUtils(this.app)
-    })
-  }
-
-  /**
-   * Registers ace with the container
-   */
-  protected registerAce() {
-    this.app.container.singleton('ace', async () => {
-      const { createAceKernel } = await import('../modules/ace/create_kernel.js')
-      return createAceKernel(this.app)
-    })
-  }
-
-  /**
-   * Registers the application to the container
-   */
-  protected registerApp() {
-    this.app.container.singleton('app', () => this.app)
-  }
-
-  /**
-   * Registers the logger class to resolve the default logger
-   */
-  protected registerLogger() {
-    this.app.container.singleton(Logger, async (resolver) => {
-      const loggerManager = await resolver.make('logger')
-      return loggerManager.use()
-    })
-  }
-
-  /**
-   * Registers the logger manager to the container
-   */
-  protected registerLoggerManager() {
-    this.app.container.singleton('logger', async () => {
-      const { LoggerManager } = await import('../modules/logger.js')
-      const config = this.app.config.get<any>('logger')
-      return new LoggerManager(config) as LoggerService
-    })
-  }
-
-  /**
-   * Registers the config to the container
-   */
-  protected registerConfig() {
-    this.app.container.singleton(Config, () => this.app.config)
-    this.app.container.alias('config', Config)
-  }
-
-  /**
-   * Registers emitter service to the container
-   */
-  protected registerEmitter() {
-    this.app.container.singleton('emitter', async () => {
-      const { Emitter } = await import('../modules/events.js')
-      return new Emitter(this.app)
-    })
-  }
-
-  /**
-   * Register the encryption service to the container
-   */
-  protected registerEncryption() {
-    this.app.container.singleton(Encryption, () => {
-      const appKey = this.app.config.get<string>('app.appKey')
-      return new Encryption({ secret: appKey })
-    })
-    this.app.container.alias('encryption', Encryption)
-  }
-
-  /**
-   * Configure the validator
-   */
-  protected async configureValidator() {
-    const config = await this.app.container.make('config')
-    validator.configure(config.get('validator', {}))
-  }
-
-  /**
-   * Registers bindings
-   */
-  register() {
-    this.registerApp()
-    this.registerAce()
-    this.registerLoggerManager()
-    this.registerLogger()
-    this.registerConfig()
-    this.registerEmitter()
-    this.registerEncryption()
-    this.registerTestUtils()
-  }
-
-  async boot() {
-    await this.configureValidator()
-  }
-}

package/providers/hash_provider.ts

@@ -1,58 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type { ApplicationService } from '../src/types.js'
-import { Argon, Bcrypt, Hash, Scrypt, driversList } from '../modules/hash/main.js'
-
-/**
- * Registers the passwords hasher with the container
- */
-export default class HashServiceProvider {
-  constructor(protected app: ApplicationService) {}
-
-  /**
-   * Registering bundled drivers with the driversList collection
-   */
-  protected registerHashDrivers() {
-    driversList.extend('bcrypt', (config) => new Bcrypt(config))
-    driversList.extend('scrypt', (config) => new Scrypt(config))
-    driversList.extend('argon2', (config) => new Argon(config))
-  }
-
-  /**
-   * Registering the hash class to resolve an instance with the
-   * default hasher.
-   */
-  protected registerHash() {
-    this.app.container.singleton(Hash, async (resolver) => {
-      const hashManager = await resolver.make('hash')
-      return hashManager.use()
-    })
-  }
-
-  /**
-   * Registers the hash manager with the container
-   */
-  protected registerHashManager() {
-    this.app.container.singleton('hash', async () => {
-      const { HashManager } = await import('../modules/hash/main.js')
-      const config = this.app.config.get<any>('hash')
-      return new HashManager(config)
-    })
-  }
-
-  /**
-   * Registers bindings
-   */
-  register() {
-    this.registerHashDrivers()
-    this.registerHashManager()
-    this.registerHash()
-  }
-}

package/providers/http_provider.ts

@@ -1,66 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import { Router, Server } from '../modules/http.js'
-import type { ApplicationService } from '../src/types.js'
-import BodyParserMiddleware from '../modules/bodyparser/bodyparser_middleware.js'
-
-/**
- * Http Service provider binds the router and the HTTP server to
- * the container.
- */
-export default class HttpServiceProvider {
-  constructor(protected app: ApplicationService) {}
-
-  /**
-   * Registers the HTTP server with the container as a singleton
-   */
-  protected registerServer() {
-    this.app.container.singleton(Server, async (resolver) => {
-      const encryption = await resolver.make('encryption')
-      const emitter = await resolver.make('emitter')
-      const logger = await resolver.make('logger')
-      const config = this.app.config.get<any>('app.http')
-      return new Server(this.app, encryption, emitter, logger, config)
-    })
-
-    this.app.container.alias('server', Server)
-  }
-
-  /**
-   * Registers router with the container as a singleton
-   */
-  protected registerRouter() {
-    this.app.container.singleton(Router, async (resolver) => {
-      const server = await resolver.make('server')
-      return server.getRouter()
-    })
-    this.app.container.alias('router', Router)
-  }
-
-  /**
-   * Self construct bodyparser middleware class, since it needs
-   * config that cannot be resolved by the container
-   */
-  protected registerBodyParserMiddleware() {
-    this.app.container.bind(BodyParserMiddleware, () => {
-      const config = this.app.config.get<any>('bodyparser')
-      return new BodyParserMiddleware(config)
-    })
-  }
-
-  /**
-   * Registers bindings
-   */
-  register() {
-    this.registerServer()
-    this.registerRouter()
-    this.registerBodyParserMiddleware()
-  }
-}

package/services/ace.ts

@@ -1,26 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { Kernel } from '../modules/ace/main.js'
-
-let ace: Kernel
-
-/**
- * Returns a singleton instance of the ace kernel
- * from the container.
- *
- * ace service is an instance of the "Kernel" class stored inside
- * the "modules/ace/kernel.ts" file
- */
-await app.booted(async () => {
-  ace = await app.container.make('ace')
-})
-
-export { ace as default }

package/services/app.ts

@@ -1,26 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type { ApplicationService } from '../src/types.js'
-
-let app: ApplicationService
-
-/**
- * Set the application instance the app service should
- * be using. Other services relies on the same app
- * instance as well.
- *
- * app service is an instance of the "Application" exported from
- * the "modules/app.ts" file.
- */
-export function setApp(appService: ApplicationService) {
-  app = appService
-}
-
-export { app as default }

package/services/config.ts

@@ -1,22 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { ApplicationService } from '../src/types.js'
-
-let config: ApplicationService['config']
-
-/**
- * The config service uses the config instance from the app service
- */
-await app.booted(() => {
-  config = app.config
-})
-
-export { config as default }

package/services/emitter.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { EmitterService } from '../src/types.js'
-
-let emitter: EmitterService
-
-/**
- * Returns a singleton instance of the emitter class
- * from the container
- */
-await app.booted(async () => {
-  emitter = await app.container.make('emitter')
-})
-
-export { emitter as default }

package/services/encryption.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { EncryptionService } from '../src/types.js'
-
-let encryption: EncryptionService
-
-/**
- * Returns a singleton instance of the encryption class
- * from the container
- */
-await app.booted(async () => {
-  encryption = await app.container.make('encryption')
-})
-
-export { encryption as default }

package/services/hash.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { HashService } from '../src/types.js'
-
-let hash: HashService
-
-/**
- * Returns a singleton instance of the Hash manager from the
- * container
- */
-await app.booted(async () => {
-  hash = await app.container.make('hash')
-})
-
-export { hash as default }

package/services/logger.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { LoggerService } from '../src/types.js'
-
-let logger: LoggerService
-
-/**
- * Returns a singleton instance of the logger class
- * from the container
- */
-await app.booted(async () => {
-  logger = await app.container.make('logger')
-})
-
-export { logger as default }

package/services/router.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { HttpRouterService } from '../src/types.js'
-
-let router: HttpRouterService
-
-/**
- * Returns a singleton instance of the router class from
- * the container
- */
-await app.booted(async () => {
-  router = await app.container.make('router')
-})
-
-export { router as default }

package/services/server.ts

@@ -1,23 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { HttpServerService } from '../src/types.js'
-
-let server: HttpServerService
-
-/**
- * Returns a singleton instance of the HTTP server
- * from the container
- */
-await app.booted(async () => {
-  server = await app.container.make('server')
-})
-
-export { server as default }

package/services/test_utils.ts

@@ -1,26 +0,0 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import app from './app.js'
-import type { TestUtils } from '../src/test_utils/main.js'
-
-let testUtils: TestUtils
-
-/**
- * Returns a singleton instance of the TestUtils class
- * from the container.
- *
- * testUtils service is an instance of the "TestUtils" exported from
- * the "src/test_utils/main.ts" file.
- */
-await app.booted(async () => {
-  testUtils = await app.container.make('testUtils')
-})
-
-export { testUtils as default }