@adonisjs/core 6.1.5-2 → 6.1.5-3

package/factories/bodyparser.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/bodyparser/factories'

package/factories/core/ace.ts

@@ -0,0 +1,38 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { IgnitorFactory } from './ignitor.js'
+import { Ignitor } from '../../src/ignitor/main.js'
+import type { IgnitorOptions } from '../../src/types.js'
+import type { Kernel } from '../../modules/ace/kernel.js'
+import { createAceKernel } from '../../modules/ace/create_kernel.js'
+
+/**
+ * Creates an instance of Ace kernel
+ */
+export class AceFactory {
+  async make(ignitor: Ignitor): Promise<Kernel>
+  async make(appRoot: URL, options: IgnitorOptions): Promise<Kernel>
+  async make(ignitorOrAppRoot: URL | Ignitor, options?: IgnitorOptions): Promise<Kernel> {
+    if (ignitorOrAppRoot instanceof Ignitor) {
+      const app = ignitorOrAppRoot.createApp('console')
+      await app.init()
+      return createAceKernel(app)
+    }
+
+    const app = new IgnitorFactory()
+      .withCoreConfig()
+      .withCoreProviders()
+      .create(ignitorOrAppRoot, options!)
+      .createApp('console')
+
+    await app.init()
+    return createAceKernel(app)
+  }
+}

package/factories/core/ignitor.ts

@@ -0,0 +1,132 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Ignitor } from '../../src/ignitor/main.js'
+import { defineConfig as defineHttpConfig } from '../../modules/http.js'
+import type { ApplicationService, IgnitorOptions } from '../../src/types.js'
+import { defineConfig as defineLoggerConfig } from '../../modules/logger.js'
+import { defineConfig as defineHashConfig } from '../../modules/hash/main.js'
+import { defineConfig as defineBodyParserConfig } from '../../modules/bodyparser/main.js'
+
+type FactoryParameters = {
+  rcFileContents: Record<string, any>
+  config: Record<string, any>
+}
+
+/**
+ * Ignitor factory creates an instance of the AdonisJS ignitor
+ */
+export class IgnitorFactory {
+  #preloadActions: ((app: ApplicationService) => Promise<void> | void)[] = []
+  #parameters: Partial<FactoryParameters> = {}
+
+  /**
+   * A flag to know if we should load the core providers
+   */
+  #loadCoreProviders: boolean = false
+
+  /**
+   * Define preload actions to run.
+   */
+  preload(action: (app: ApplicationService) => void | Promise<void>): this {
+    this.#preloadActions.push(action)
+    return this
+  }
+
+  /**
+   * Merge core providers with user defined providers
+   */
+  #mergeCoreProviders(providers?: string[]) {
+    return [
+      '@adonisjs/core/providers/app_provider',
+      '@adonisjs/core/providers/hash_provider',
+      '@adonisjs/core/providers/http_provider',
+    ].concat(providers || [])
+  }
+
+  /**
+   * Merge custom factory parameters
+   */
+  merge(params: Partial<FactoryParameters>): this {
+    if (params.config) {
+      this.#parameters.config = Object.assign(this.#parameters.config || {}, params.config)
+    }
+
+    if (params.rcFileContents) {
+      this.#parameters.rcFileContents = Object.assign(
+        this.#parameters.rcFileContents || {},
+        params.rcFileContents
+      )
+    }
+
+    return this
+  }
+
+  /**
+   * Load core provider when booting the app
+   */
+  withCoreProviders(): this {
+    this.#loadCoreProviders = true
+    return this
+  }
+
+  /**
+   * Merge default config for the core features. A shallow merge
+   * is performed.
+   */
+  withCoreConfig(): this {
+    this.merge({
+      config: {
+        app: {
+          appKey: 'averylongrandomsecretkey',
+          http: defineHttpConfig({}),
+        },
+        validator: {},
+        bodyparser: defineBodyParserConfig({}),
+        hash: defineHashConfig({
+          default: 'scrypt',
+          list: {
+            scrypt: {
+              driver: 'scrypt',
+            },
+          },
+        }),
+        logger: defineLoggerConfig({
+          default: 'app',
+          loggers: {
+            app: {},
+          },
+        }),
+      },
+    })
+    return this
+  }
+
+  /**
+   * Create ignitor instance
+   */
+  create(appRoot: URL, options: IgnitorOptions): Ignitor {
+    return new Ignitor(appRoot, options).tap((app) => {
+      app.booted(async () => {
+        for (let action of this.#preloadActions) {
+          await action(app)
+        }
+      })
+
+      if (this.#loadCoreProviders) {
+        this.#parameters.rcFileContents = this.#parameters.rcFileContents || {}
+        this.#parameters.rcFileContents.providers = this.#mergeCoreProviders(
+          this.#parameters.rcFileContents.providers
+        )
+      }
+      this.#parameters.rcFileContents && app.rcContents(this.#parameters.rcFileContents)
+      this.#parameters.config && app.useConfig(this.#parameters.config)
+    })
+  }
+}

package/factories/core/main.ts

@@ -0,0 +1,13 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export { AceFactory } from './ace.js'
+export { StubsFactory } from '../stubs.js'
+export { IgnitorFactory } from './ignitor.js'
+export { TestUtilsFactory } from './test_utils.js'

package/factories/core/test_utils.ts

@@ -0,0 +1,34 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Ignitor } from '../../index.js'
+import { IgnitorFactory } from './ignitor.js'
+import type { IgnitorOptions } from '../../src/types.js'
+import { TestUtils } from '../../src/test_utils/main.js'
+
+/**
+ * Creates an instance of TestUtils class
+ */
+export class TestUtilsFactory {
+  create(ignitor: Ignitor): TestUtils
+  create(appRoot: URL, options: IgnitorOptions): TestUtils
+  create(ignitorOrAppRoot: URL | Ignitor, options?: IgnitorOptions): TestUtils {
+    if (ignitorOrAppRoot instanceof Ignitor) {
+      return new TestUtils(ignitorOrAppRoot.createApp('test'))
+    }
+
+    return new TestUtils(
+      new IgnitorFactory()
+        .withCoreConfig()
+        .withCoreProviders()
+        .create(ignitorOrAppRoot, options!)
+        .createApp('console')
+    )
+  }
+}

package/factories/encryption.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/encryption/factories'

package/factories/events.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/events/factories'

package/factories/hash.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/factories'

package/factories/http.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/factories'

package/factories/logger.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/factories'

package/factories/stubs.ts

@@ -0,0 +1,53 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { AppFactory } from '@adonisjs/application/factories'
+
+import { stubsRoot } from '../index.js'
+import type { ApplicationService } from '../src/types.js'
+
+type FactoryParameters = {
+  app: ApplicationService
+}
+
+/**
+ * Prepares stubs from "@adonisjs/core" package. We do not publish this class as it
+ * is for internal testing only using the "stubsRoot" of the core package
+ */
+export class StubsFactory {
+  #parameters: Partial<FactoryParameters> = {}
+
+  /**
+   * Returns an instance of application
+   */
+  #getApp() {
+    return this.#parameters.app || new AppFactory().create(new URL('./', import.meta.url), () => {})
+  }
+
+  /**
+   * Merge custom factory parameters
+   */
+  merge(params: Partial<FactoryParameters>): this {
+    this.#parameters = Object.assign(this.#parameters, params)
+    return this
+  }
+
+  /**
+   * Prepares a stub
+   */
+  async prepare(stubPath: string, data: Record<string, any>) {
+    const app = this.#getApp()
+    await app.init()
+
+    const stub = await app.stubs.build(stubPath, {
+      source: stubsRoot,
+    })
+    return stub.prepare(data)
+  }
+}

package/index.ts

@@ -0,0 +1,39 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { errors as aceErrors } from '@adonisjs/ace'
+import { errors as envErrors } from '@adonisjs/env'
+import { errors as appErrors } from '@adonisjs/application'
+import { errors as encryptionErrors } from '@adonisjs/encryption'
+import { errors as httpServerErrors } from '@adonisjs/http-server'
+
+export { stubsRoot } from './stubs/index.js'
+export { inject } from './modules/container.js'
+export { Ignitor } from './src/ignitor/main.js'
+
+export const errors = {
+  ...encryptionErrors,
+  ...httpServerErrors,
+  ...appErrors,
+  ...aceErrors,
+  ...envErrors,
+}
+
+/**
+ * Pretty prints an error with colorful output using
+ * Youch terminal
+ */
+export async function prettyPrintError(error: any) {
+  // @ts-expect-error
+  const { default: youchTerminal } = await import('youch-terminal')
+  const { default: Youch } = await import('youch')
+
+  const youch = new Youch(error, {})
+  console.error(youchTerminal(await youch.toJSON(), { displayShortPath: true }))
+}

package/legacy/validator.ts

@@ -0,0 +1,10 @@
+/*
+ * @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/validator'

package/modules/ace/commands.ts

@@ -0,0 +1,152 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { BaseCommand as AceBaseCommand, ListCommand as AceListCommand } from '@adonisjs/ace'
+
+import { Kernel } from './kernel.js'
+import type { ApplicationService } from '../../src/types.js'
+import type { CommandOptions, ParsedOutput, UIPrimitives } from '../../types/ace.js'
+
+/**
+ * The base command to create custom ace commands. The AdonisJS base commands
+ * receives the application instance
+ */
+export class BaseCommand extends AceBaseCommand {
+  static options: CommandOptions = {}
+
+  get staysAlive() {
+    return (this.constructor as typeof BaseCommand).options.staysAlive
+  }
+
+  get startApp() {
+    return (this.constructor as typeof BaseCommand).options.startApp
+  }
+
+  constructor(
+    public app: ApplicationService,
+    public kernel: Kernel,
+    parsed: ParsedOutput,
+    ui: UIPrimitives,
+    prompt: Kernel['prompt']
+  ) {
+    super(kernel, parsed, ui, prompt)
+  }
+
+  /**
+   * The prepare template method is used to prepare the
+   * state for the command. This is the first method
+   * executed on a given command instance.
+   */
+  prepare?(..._: any[]): any
+
+  /**
+   * The interact template method is used to display the prompts
+   * to the user. The method is called after the prepare
+   * method.
+   */
+  interact?(..._: any[]): any
+
+  /**
+   * The completed method is the method invoked after the command
+   * finishes or results in an error.
+   *
+   * You can access the command error using the `this.error` property.
+   * Returning `true` from completed method supresses the error
+   * reporting to the kernel layer.
+   */
+  completed?(..._: any[]): any
+
+  /**
+   * Executes the command
+   */
+  async exec() {
+    this.hydrate()
+
+    try {
+      /**
+       * Executing the template methods
+       */
+      this.prepare && (await this.app.container.call<any, 'prepare'>(this, 'prepare'))
+      this.interact && (await this.app.container.call<any, 'interact'>(this, 'interact'))
+      const result = await this.app.container.call<BaseCommand, 'run'>(this, 'run')
+
+      /**
+       * Set exit code
+       */
+      this.result = this.result === undefined ? result : this.result
+      this.exitCode = this.exitCode ?? 0
+    } catch (error) {
+      this.error = error
+      this.exitCode = this.exitCode ?? 1
+    }
+
+    /**
+     * Run the completed method (if exists) and check if has handled
+     * the error
+     */
+    let errorHandled = this.completed
+      ? await this.app.container.call<any, 'completed'>(this, 'completed')
+      : false
+
+    if (this.error && !errorHandled) {
+      this.logger.fatal(this.error)
+    }
+
+    return this.result
+  }
+
+  /**
+   * Terminate the app. A command should prefer calling this method
+   * over the "app.terminate", because this method only triggers
+   * app termination when the current command is in the charge
+   * of the process.
+   */
+  async terminate() {
+    if (this.kernel.getMainCommand() === this) {
+      await this.app.terminate()
+    }
+  }
+}
+
+/**
+ * The List command is used to display a list of commands
+ */
+export class ListCommand extends AceListCommand implements BaseCommand {
+  static options: CommandOptions = {}
+
+  get staysAlive() {
+    return (this.constructor as typeof BaseCommand).options.staysAlive
+  }
+
+  get startApp() {
+    return (this.constructor as typeof BaseCommand).options.startApp
+  }
+
+  constructor(
+    public app: ApplicationService,
+    public kernel: Kernel,
+    parsed: ParsedOutput,
+    ui: UIPrimitives,
+    prompt: Kernel['prompt']
+  ) {
+    super(kernel, parsed, ui, prompt)
+  }
+
+  /**
+   * Terminate the app. A command should prefer calling this method
+   * over the "app.terminate", because this method only triggers
+   * app termination when the current command is in the charge
+   * of the process.
+   */
+  async terminate() {
+    if (this.kernel.getMainCommand() === this) {
+      await this.app.terminate()
+    }
+  }
+}

package/modules/ace/create_kernel.ts

@@ -0,0 +1,73 @@
+/*
+ * @adonisjs/ace
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Kernel } from './main.js'
+import type { ApplicationService } from '../../src/types.js'
+import { FsLoader, HelpCommand } from '../../modules/ace/main.js'
+
+/**
+ * We abstract the logic for creating the ace kernel in this
+ * file. So that both the "console" environment and rest
+ * of the environments can configure and use ace.
+ *
+ * - In console environment, ace manages the lifecycle of the process
+ * - In other environments, ace can be pulled from the container to
+ * run commands
+ */
+export function createAceKernel(app: ApplicationService) {
+  const kernel = new Kernel(app)
+  kernel.addLoader(new FsLoader(app.commandsPath()))
+
+  /**
+   * Lazy import commands mentioned in the "commands" array
+   * of rcFile
+   */
+  app.rcFile.commands.forEach((commandModule) => {
+    kernel.addLoader(() => app.import(commandModule))
+  })
+
+  /**
+   * Custom global flags
+   */
+  kernel.defineFlag('ansi', {
+    type: 'boolean',
+    showNegatedVariantInHelp: true,
+    description: 'Force enable or disable colorful output',
+  })
+
+  kernel.defineFlag('help', {
+    type: 'boolean',
+    description: HelpCommand.description,
+  })
+
+  /**
+   * Flag listener to turn colors on/off
+   */
+  kernel.on('ansi', (_, $kernel, parsed) => {
+    if (parsed.flags.ansi === false) {
+      $kernel.ui.switchMode('silent')
+    }
+
+    if (parsed.flags.ansi === true) {
+      $kernel.ui.switchMode('normal')
+    }
+  })
+
+  /**
+   * Flag listener to display the help
+   */
+  kernel.on('help', async (command, $kernel, parsed) => {
+    parsed.args.unshift(command.commandName)
+    const help = new HelpCommand($kernel, parsed, kernel.ui, kernel.prompt)
+    await help.exec()
+    return $kernel.shortcircuit()
+  })
+
+  return kernel
+}

package/modules/ace/kernel.ts

@@ -0,0 +1,28 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Kernel as AceKernel } from '@adonisjs/ace'
+import { BaseCommand, ListCommand } from './commands.js'
+import type { ApplicationService } from '../../src/types.js'
+
+/**
+ * The base command to create custom ace commands. The AdonisJS base commands
+ * receives the application instance
+ */
+export class Kernel extends AceKernel<typeof BaseCommand> {
+  constructor(public app: ApplicationService) {
+    super(ListCommand, {
+      create: async (command, parsedOutput, $kernel) => {
+        return app.container.make(command, [app, $kernel, parsedOutput, $kernel.ui, $kernel.prompt])
+      },
+
+      run: (command) => command.exec(),
+    })
+  }
+}

package/modules/ace/main.ts

@@ -0,0 +1,22 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export { Kernel } from './kernel.js'
+export { BaseCommand, ListCommand } from './commands.js'
+export {
+  args,
+  flags,
+  errors,
+  Parser,
+  FsLoader,
+  ListLoader,
+  cliHelpers,
+  HelpCommand,
+  IndexGenerator,
+} from '@adonisjs/ace'