@adonisjs/core 6.1.5-1 → 6.1.5-3

package/src/internal_helpers.ts

@@ -0,0 +1,59 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import fs from 'node:fs'
+import { ApplicationService } from './types.js'
+
+/**
+ * Imports assembler optionally
+ */
+export async function importAssembler(
+  app: ApplicationService
+): Promise<typeof import('@adonisjs/assembler') | undefined> {
+  try {
+    return await app.import('@adonisjs/assembler')
+  } catch {}
+}
+
+/**
+ * Imports typescript optionally
+ */
+export async function importTypeScript(
+  app: ApplicationService
+): Promise<typeof import('typescript') | undefined> {
+  try {
+    return await app.importDefault('typescript')
+  } catch {}
+}
+
+/**
+ * Detects the assets bundler in use. The rcFile.assetsBundler is
+ * used when exists.
+ */
+export async function detectAssetsBundler(app: ApplicationService) {
+  if (app.rcFile.assetsBundler) {
+    return app.rcFile.assetsBundler
+  }
+
+  if (fs.existsSync(app.makePath('vite.config.js'))) {
+    return {
+      name: 'vite',
+      devServerCommand: 'vite',
+      buildCommand: 'vite build',
+    }
+  }
+
+  if (fs.existsSync(app.makePath('webpack.config.js'))) {
+    return {
+      name: 'encore',
+      devServerCommand: 'encore dev-server',
+      buildCommand: 'encore',
+    }
+  }
+}

package/src/test_utils/http.ts

@@ -0,0 +1,79 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import debug from '../debug.js'
+import type { TestUtils } from './main.js'
+import type { Server as NodeHttpsServer } from 'node:https'
+import { IncomingMessage, ServerResponse, Server as NodeHttpServer, createServer } from 'node:http'
+
+/**
+ * Http server utils are used to start the AdonisJS HTTP server
+ * during testing
+ */
+export class HttpServerUtils {
+  #utils: TestUtils
+
+  constructor(utils: TestUtils) {
+    this.#utils = utils
+  }
+
+  /**
+   * Starts the http server a given host and port
+   */
+  #listen(
+    nodeHttpServer: NodeHttpsServer | NodeHttpServer
+  ): Promise<{ port: number; host: string }> {
+    return new Promise((resolve, reject) => {
+      const host = process.env.HOST || '0.0.0.0'
+      const port = Number(process.env.PORT || '3333')
+
+      nodeHttpServer.listen(port, host)
+      nodeHttpServer.once('listening', () => {
+        debug('listening to utils http server, host :%s, port: %s', host, port)
+        resolve({ port, host })
+      })
+
+      nodeHttpServer.once('error', (error: NodeJS.ErrnoException) => {
+        reject(error)
+      })
+    })
+  }
+
+  /**
+   * Testing hook to start the HTTP server to listen for new request.
+   * The return value is a function to close the HTTP server.
+   */
+  async start(
+    serverCallback?: (
+      handler: (req: IncomingMessage, res: ServerResponse) => any
+    ) => NodeHttpsServer | NodeHttpServer
+  ): Promise<() => Promise<void>> {
+    const createHTTPServer = serverCallback || createServer
+
+    const server = await this.#utils.app.container.make('server')
+    await server.boot()
+
+    const httpServer = createHTTPServer(server.handle.bind(server))
+    server.setNodeServer(httpServer)
+
+    await this.#listen(httpServer)
+
+    return () => {
+      return new Promise<void>((resolve, reject) => {
+        httpServer.close((error) => {
+          if (error) {
+            reject(error)
+          } else {
+            resolve()
+          }
+        })
+      })
+    }
+  }
+}

package/src/test_utils/main.ts

@@ -0,0 +1,69 @@
+/*
+ * @adonisjs/core
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Socket } from 'node:net'
+import Macroable from '@poppinss/macroable'
+import { IncomingMessage, ServerResponse } from 'node:http'
+
+import { HttpServerUtils } from './http.js'
+import { CookieClient } from '../../modules/http.js'
+import type { ApplicationService } from '../types.js'
+
+/**
+ * Test utils has a collection of helper methods to make testing
+ * experience great for AdonisJS applications
+ */
+export class TestUtils extends Macroable {
+  #booted: boolean = false
+
+  /**
+   * Check if utils have been booted
+   */
+  get isBooted() {
+    return this.#booted
+  }
+
+  declare cookies: CookieClient
+
+  constructor(public app: ApplicationService) {
+    super()
+  }
+
+  /**
+   * Boot test utils. It requires the app to be booted
+   * and container to have all the bindings
+   */
+  async boot() {
+    if (!this.isBooted) {
+      this.#booted = true
+      this.cookies = new CookieClient(await this.app.container.make('encryption'))
+    }
+  }
+
+  /**
+   * Returns an instance of the HTTP server testing
+   * utils
+   */
+  httpServer() {
+    return new HttpServerUtils(this)
+  }
+
+  /**
+   * Create an instance of HTTP context for testing
+   */
+  async createHttpContext(options: { req?: IncomingMessage; res?: ServerResponse } = {}) {
+    const req = options.req || new IncomingMessage(new Socket())
+    const res = options.res || new ServerResponse(req)
+    const server = await this.app.container.make('server')
+
+    const request = server.createRequest(req, res)
+    const response = server.createResponse(req, res)
+    return server.createHttpContext(request, response, this.app.container.createResolver())
+  }
+}

package/src/types.ts

@@ -0,0 +1,136 @@
+/*
+ * @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 { Importer } from '../types/app.js'
+import type { Emitter } from '../modules/events.js'
+import type { Kernel } from '../modules/ace/main.js'
+import type { Application } from '../modules/app.js'
+import type { TestUtils } from './test_utils/main.js'
+import type { Router, Server } from '../modules/http.js'
+import type { LoggerManager } from '../modules/logger.js'
+import type { Encryption } from '../modules/encryption.js'
+import type { HttpRequestFinishedPayload } from '../types/http.js'
+import type { ContainerResolveEventData } from '../types/container.js'
+import type { LoggerConfig, LoggerManagerConfig } from '../types/logger.js'
+import type { Argon, Bcrypt, HashManager, Scrypt } from '../modules/hash/main.js'
+import type {
+  ArgonConfig,
+  BcryptConfig,
+  ScryptConfig,
+  ManagerDriverFactory,
+} from '../types/hash.js'
+
+/**
+ * Options accepted by ignitor
+ */
+export type IgnitorOptions = { importer: Importer }
+
+/**
+ * A list of known events. The interface must be extended in
+ * user land code or packages to register events and their
+ * types.
+ */
+export interface EventsList {
+  'container:resolved': ContainerResolveEventData<ContainerBindings>
+  'http:request_handled': HttpRequestFinishedPayload
+  'http:server_ready': { port: number; host: string }
+}
+
+/**
+ * The loggers list inferred from the user application
+ * config
+ */
+export interface LoggersList {}
+export type InferLoggers<T extends LoggerManagerConfig<any>> = T['loggers']
+
+/**
+ * A list of globally available hash drivers
+ */
+export interface HashDriversList {
+  bcrypt: (config: BcryptConfig) => Bcrypt
+  argon2: (config: ArgonConfig) => Argon
+  scrypt: (config: ScryptConfig) => Scrypt
+}
+
+/**
+ * A list of known hashers inferred from the user config
+ */
+export interface HashersList {}
+export type InferHashers<T extends { list: Record<string, ManagerDriverFactory> }> = T['list']
+
+/**
+ * ----------------------------------------------------------------
+ * Container services
+ * -----------------------------------------------------------------
+ *
+ * Types for the container singleton services. Defining them
+ * upfront so that we do not have to define them in
+ * multiple places.
+ */
+
+/**
+ * Application service is a singleton resolved from
+ * the container
+ */
+export interface ApplicationService
+  extends Application<ContainerBindings extends Record<any, any> ? ContainerBindings : never> {}
+
+/**
+ * Logger service is a singleton logger instance registered
+ * to the container.
+ */
+export interface LoggerService
+  extends LoggerManager<LoggersList extends Record<string, LoggerConfig> ? LoggersList : never> {}
+
+/**
+ * Emitter service is a singleton emitter instance registered
+ * to the container.
+ */
+export interface EmitterService extends Emitter<EventsList> {}
+
+/**
+ * Encryption service is a singleton Encryption class instance
+ * registered to the container.
+ */
+export interface EncryptionService extends Encryption {}
+
+/**
+ * Http server service added to the container as a singleton
+ */
+export interface HttpServerService extends Server {}
+
+/**
+ * Http server service added to the container as a singleton
+ */
+export interface HttpRouterService extends Router {}
+
+/**
+ * Hash service is a singleton instance of the HashManager
+ * registered in the container
+ */
+export interface HashService
+  extends HashManager<
+    HashersList extends Record<string, ManagerDriverFactory> ? HashersList : never
+  > {}
+
+/**
+ * A list of known container bindings.
+ */
+export interface ContainerBindings {
+  ace: Kernel
+  app: ApplicationService
+  logger: LoggerService
+  config: ApplicationService['config']
+  emitter: EmitterService
+  encryption: EncryptionService
+  hash: HashService
+  server: HttpServerService
+  router: HttpRouterService
+  testUtils: TestUtils
+}

package/types/ace.ts

@@ -0,0 +1,15 @@
+/*
+ * @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 { CommandOptions as BaseCommandOptions } from '@adonisjs/ace/types'
+export type CommandOptions = BaseCommandOptions & {
+  startApp?: boolean
+}
+
+export * from '@adonisjs/ace/types'

package/types/app.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/application/types'

package/types/bodyparser.ts

@@ -0,0 +1,10 @@
+/*
+ * @adonisjs/ace
+ *
+ * (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/types'

package/types/container.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/fold/types'

package/types/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/types'

package/types/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/types'

package/types/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/types'

package/types/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/types'

package/types/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/types'

package/build/src/helpers/string_builder.d.ts

@@ -1,23 +0,0 @@
-export declare class StringBuilder {
-    #private;
-    constructor(value: string | StringBuilder);
-    dashCase(): this;
-    dotCase(): this;
-    snakeCase(): this;
-    pascalCase(): this;
-    camelCase(): this;
-    capitalCase(): this;
-    titleCase(): this;
-    sentenceCase(): this;
-    noCase(): this;
-    plural(): this;
-    singular(): this;
-    slugify(): this;
-    removeSuffix(suffix: string): this;
-    suffix(suffix: string): this;
-    removePrefix(prefix: string): this;
-    prefix(prefix: string): this;
-    removeExtension(): this;
-    ext(extension: string): this;
-    toString(): string;
-}

package/build/src/helpers/string_builder.js

@@ -1,86 +0,0 @@
-import { extname } from 'node:path';
-import string from './string.js';
-export class StringBuilder {
-    #value;
-    constructor(value) {
-        this.#value = typeof value === 'string' ? value : value.toString();
-    }
-    dashCase() {
-        this.#value = string.dashCase(this.#value);
-        return this;
-    }
-    dotCase() {
-        this.#value = string.dotCase(this.#value);
-        return this;
-    }
-    snakeCase() {
-        this.#value = string.snakeCase(this.#value);
-        return this;
-    }
-    pascalCase() {
-        this.#value = string.pascalCase(this.#value);
-        return this;
-    }
-    camelCase() {
-        this.#value = string.camelCase(this.#value);
-        return this;
-    }
-    capitalCase() {
-        this.#value = string.capitalCase(this.#value);
-        return this;
-    }
-    titleCase() {
-        this.#value = string.titleCase(this.#value);
-        return this;
-    }
-    sentenceCase() {
-        this.#value = string.sentenceCase(this.#value);
-        return this;
-    }
-    noCase() {
-        this.#value = string.noCase(this.#value);
-        return this;
-    }
-    plural() {
-        this.#value = string.pluralize(this.#value);
-        return this;
-    }
-    singular() {
-        this.#value = string.singular(this.#value);
-        return this;
-    }
-    slugify() {
-        this.#value = string.slug(this.#value);
-        return this;
-    }
-    removeSuffix(suffix) {
-        this.#value = this.#value.replace(new RegExp(`[-_]?${suffix}$`, 'i'), '');
-        return this;
-    }
-    suffix(suffix) {
-        this.removeSuffix(suffix);
-        this.#value = `${this.#value}${suffix}`;
-        return this;
-    }
-    removePrefix(prefix) {
-        this.#value = this.#value.replace(new RegExp(`^${prefix}[-_]?`, 'i'), '');
-        return this;
-    }
-    prefix(prefix) {
-        this.removePrefix(prefix);
-        this.#value = `${prefix}${this.#value}`;
-        return this;
-    }
-    removeExtension() {
-        this.#value = this.#value.replace(new RegExp(`${extname(this.#value)}$`), '');
-        return this;
-    }
-    ext(extension) {
-        this.removeExtension();
-        this.#value = `${this.#value}.${extension.replace(/^\./, '')}`;
-        return this;
-    }
-    toString() {
-        return this.#value;
-    }
-}