@adonisjs/core 5.9.0 → 6.0.1-0

package/build/src/ignitor/http.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Server as NodeHttpsServer } from 'node:https';
+import { IncomingMessage, ServerResponse, Server as NodeHttpServer } from 'node:http';
+import { Ignitor } from './main.js';
+export declare class HttpServerProcess {
+    #private;
+    constructor(ignitor: Ignitor);
+    start(serverCallback?: (handler: (req: IncomingMessage, res: ServerResponse) => any) => NodeHttpsServer | NodeHttpServer): Promise<void>;
+}

package/build/src/ignitor/http.js

@@ -0,0 +1,62 @@
+import { createServer } from 'node:http';
+import debug from '../debug.js';
+export class HttpServerProcess {
+    #ignitor;
+    constructor(ignitor) {
+        this.#ignitor = ignitor;
+    }
+    #close(nodeHttpServer) {
+        return new Promise((resolve) => {
+            debug('closing http server process');
+            nodeHttpServer.close(() => resolve());
+        });
+    }
+    #monitorAppAndServer(nodeHttpServer, app, logger) {
+        app.terminating(async () => {
+            debug('terminating signal received');
+            await this.#close(nodeHttpServer);
+        });
+        nodeHttpServer.once('error', (error) => {
+            debug('http server crashed with error "%O"', error);
+            logger.fatal({ err: error }, error.message);
+            process.exitCode = 1;
+            app.terminate();
+        });
+    }
+    #listen(nodeHttpServer) {
+        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 http server, host :%s, port: %s', host, port);
+                resolve({ port, host });
+            });
+            nodeHttpServer.once('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    #notifyServerHasStarted(app, logger, emitter, payload) {
+        app.notify({ isAdonisJS: true, environment: 'web', ...payload });
+        logger.info('started HTTP server on %s:%s', payload.host, payload.port);
+        emitter.emit('http:server_ready', payload);
+    }
+    async start(serverCallback) {
+        const createHTTPServer = serverCallback || createServer;
+        const app = this.#ignitor.createApp('web');
+        await app.init();
+        await app.boot();
+        await app.start(async () => {
+            const server = await app.container.make('server');
+            await server.boot();
+            const httpServer = createHTTPServer(server.handle.bind(server));
+            server.setNodeServer(httpServer);
+            const logger = await app.container.make('logger');
+            const emitter = await app.container.make('emitter');
+            const payload = await this.#listen(httpServer);
+            this.#notifyServerHasStarted(app, logger, emitter, payload);
+            this.#monitorAppAndServer(httpServer, app, logger);
+        });
+    }
+}

package/build/src/ignitor/main.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AceProcess } from './ace.js';
+import { TestRunnerProcess } from './test.js';
+import { HttpServerProcess } from './http.js';
+import type { AppEnvironments } from '../../types/app.js';
+import type { ApplicationService, IgnitorOptions } from '../types.js';
+export declare class Ignitor {
+    #private;
+    constructor(appRoot: URL, options: IgnitorOptions);
+    getApp(): ApplicationService | undefined;
+    createApp(environment: AppEnvironments): ApplicationService;
+    tap(callback: (app: ApplicationService) => void): this;
+    httpServer(): HttpServerProcess;
+    ace(): AceProcess;
+    testRunner(): TestRunnerProcess;
+    terminate(): Promise<void>;
+}

package/build/src/ignitor/main.js

@@ -0,0 +1,45 @@
+import debug from '../debug.js';
+import { AceProcess } from './ace.js';
+import { TestRunnerProcess } from './test.js';
+import { HttpServerProcess } from './http.js';
+import { setApp } from '../../services/app.js';
+import { Application } from '../../modules/app.js';
+export class Ignitor {
+    #options;
+    #appRoot;
+    #app;
+    #tapCallbacks = new Set();
+    constructor(appRoot, options) {
+        this.#appRoot = appRoot;
+        this.#options = options;
+    }
+    #runTapCallbacks(app) {
+        this.#tapCallbacks.forEach((tapCallback) => tapCallback(app));
+    }
+    getApp() {
+        return this.#app;
+    }
+    createApp(environment) {
+        debug('creating application instance');
+        this.#app = new Application(this.#appRoot, { environment, importer: this.#options.importer });
+        setApp(this.#app);
+        this.#runTapCallbacks(this.#app);
+        return this.#app;
+    }
+    tap(callback) {
+        this.#tapCallbacks.add(callback);
+        return this;
+    }
+    httpServer() {
+        return new HttpServerProcess(this);
+    }
+    ace() {
+        return new AceProcess(this);
+    }
+    testRunner() {
+        return new TestRunnerProcess(this);
+    }
+    async terminate() {
+        await this.#app?.terminate();
+    }
+}

package/build/src/ignitor/test.d.ts

@@ -0,0 +1,8 @@
+import { Ignitor } from './main.js';
+import type { ApplicationService } from '../types.js';
+export declare class TestRunnerProcess {
+    #private;
+    constructor(ignitor: Ignitor);
+    configure(callback: (app: ApplicationService) => Promise<void> | void): this;
+    run(callback: (app: ApplicationService) => Promise<void> | void): Promise<void>;
+}

package/build/src/ignitor/test.js

@@ -0,0 +1,18 @@
+export class TestRunnerProcess {
+    #ignitor;
+    #configureCallback = () => { };
+    constructor(ignitor) {
+        this.#ignitor = ignitor;
+    }
+    configure(callback) {
+        this.#configureCallback = callback;
+        return this;
+    }
+    async run(callback) {
+        const app = this.#ignitor.createApp('test');
+        await app.init();
+        await app.boot();
+        await app.start(this.#configureCallback);
+        await callback(app);
+    }
+}

package/build/src/test_utils/http.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { TestUtils } from './main.js';
+import type { Server as NodeHttpsServer } from 'node:https';
+import { IncomingMessage, ServerResponse, Server as NodeHttpServer } from 'node:http';
+export declare class HttpServerUtils {
+    #private;
+    constructor(utils: TestUtils);
+    start(serverCallback?: (handler: (req: IncomingMessage, res: ServerResponse) => any) => NodeHttpsServer | NodeHttpServer): Promise<() => Promise<void>>;
+}

package/build/src/test_utils/http.js

@@ -0,0 +1,42 @@
+import debug from '../debug.js';
+import { createServer } from 'node:http';
+export class HttpServerUtils {
+    #utils;
+    constructor(utils) {
+        this.#utils = utils;
+    }
+    #listen(nodeHttpServer) {
+        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) => {
+                reject(error);
+            });
+        });
+    }
+    async start(serverCallback) {
+        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((resolve, reject) => {
+                httpServer.close((error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        };
+    }
+}

package/build/src/test_utils/main.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+import Macroable from '@poppinss/macroable';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { HttpServerUtils } from './http.js';
+import type { ApplicationService } from '../types.js';
+import { CookieClient } from '../../modules/http.js';
+export declare class TestUtils extends Macroable {
+    #private;
+    app: ApplicationService;
+    get isBooted(): boolean;
+    cookies: CookieClient;
+    constructor(app: ApplicationService);
+    boot(): Promise<void>;
+    httpServer(): HttpServerUtils;
+    createHttpContext(options?: {
+        req?: IncomingMessage;
+        res?: ServerResponse;
+    }): Promise<import("../../modules/http.js").HttpContext>;
+}

package/build/src/test_utils/main.js

@@ -0,0 +1,33 @@
+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';
+export class TestUtils extends Macroable {
+    app;
+    #booted = false;
+    get isBooted() {
+        return this.#booted;
+    }
+    constructor(app) {
+        super();
+        this.app = app;
+    }
+    async boot() {
+        if (!this.isBooted) {
+            this.#booted = true;
+            this.cookies = new CookieClient(await this.app.container.make('encryption'));
+        }
+    }
+    httpServer() {
+        return new HttpServerUtils(this);
+    }
+    async createHttpContext(options = {}) {
+        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/build/src/types.d.ts

@@ -0,0 +1,63 @@
+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 { LoggerConfig, LoggerManagerConfig } from '../types/logger.js';
+import type hashDriversCollection from '../modules/hash/drivers_collection.js';
+import type { Argon, Bcrypt, HashManager, Scrypt } from '../modules/hash/main.js';
+import type { ArgonConfig, BcryptConfig, ScryptConfig, ManagerDriverFactory } from '../types/hash.js';
+export type IgnitorOptions = {
+    importer: Importer;
+};
+export interface EventsList {
+    'http:request_handled': HttpRequestFinishedPayload;
+    'http:server_ready': {
+        port: number;
+        host: string;
+    };
+}
+export interface LoggersList {
+}
+export type InferLoggers<T extends LoggerManagerConfig<any>> = T['loggers'];
+export interface HashDriversList {
+    bcrypt: (config: BcryptConfig) => Bcrypt;
+    argon2: (config: ArgonConfig) => Argon;
+    scrypt: (config: ScryptConfig) => Scrypt;
+}
+export interface HashersList {
+}
+export type InferHashers<T extends {
+    list: Record<string, ManagerDriverFactory>;
+}> = T['list'];
+export interface ApplicationService extends Application<ContainerBindings extends Record<any, any> ? ContainerBindings : never> {
+}
+export interface LoggerService extends LoggerManager<LoggersList extends Record<string, LoggerConfig> ? LoggersList : never> {
+}
+export interface EmitterService extends Emitter<EventsList> {
+}
+export interface EncryptionService extends Encryption {
+}
+export interface HttpServerService extends Server {
+}
+export interface HttpRouterService extends Router {
+}
+export interface HashService extends HashManager<HashersList extends Record<string, ManagerDriverFactory> ? HashersList : never> {
+}
+export interface ContainerBindings {
+    ace: Kernel;
+    app: ApplicationService;
+    logger: LoggerService;
+    config: ApplicationService['config'];
+    emitter: EmitterService;
+    encryption: EncryptionService;
+    hash: HashService;
+    hashDrivers: typeof hashDriversCollection;
+    server: HttpServerService;
+    router: HttpRouterService;
+    testUtils: TestUtils;
+}

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/stubs/index.d.ts

@@ -0,0 +1 @@
+export declare const stubsRoot: string;

package/build/stubs/index.js

@@ -0,0 +1,2 @@
+import { getDirname } from '@poppinss/utils';
+export const stubsRoot = getDirname(import.meta.url);

package/build/stubs/make/command/main.stub

@@ -0,0 +1,19 @@
+{{#var commandName = generators.commandName(entity.name)}}
+{{#var commandTerminalName = generators.commandTerminalName(entity.name)}}
+{{#var commandFileName = generators.commandFileName(entity.name)}}
+---
+to: {{ app.commandsPath(entity.path, commandFileName) }}
+---
+import { BaseCommand } from '@adonisjs/core/ace'
+import { CommandOptions } from '@adonisjs/core/types'
+
+export default class {{ commandName }} extends BaseCommand {
+  static commandName = '{{ commandTerminalName }}'
+  static description = ''
+
+  static options: CommandOptions = {}
+
+  async run() {
+    this.info('Hello world from "{{ commandName }}"')
+  }
+}

package/build/stubs/make/controller/api.stub

@@ -0,0 +1,33 @@
+{{#var controllerName = generators.controllerName(entity.name)}}
+{{#var controllerFileName = generators.controllerFileName(entity.name)}}
+---
+to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
+---
+import { HttpContext } from '@adonisjs/core/http'
+
+export default class {{ controllerName }} {
+  /**
+   * Display a list of resource
+   */
+  async index({}: HttpContext) {}
+
+  /**
+   * Handle form submission for the create action
+   */
+  async store({ request }: HttpContext) {}
+
+  /**
+   * Show individual record
+   */
+  async show({ params }: HttpContext) {}
+
+  /**
+   * Handle form submission for the edit action
+   */
+  async update({ params, request }: HttpContext) {}
+
+  /**
+   * Delete record
+   */
+  async destroy({ params }: HttpContext) {}
+}

package/build/stubs/make/controller/main.stub

@@ -0,0 +1,9 @@
+{{#var controllerName = generators.controllerName(entity.name)}}
+{{#var controllerFileName = generators.controllerFileName(entity.name)}}
+---
+to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
+---
+// import { HttpContext } from '@adonisjs/core/http'
+
+export default class {{ controllerName }} {
+}

package/build/stubs/make/controller/resource.stub

@@ -0,0 +1,43 @@
+{{#var controllerName = generators.controllerName(entity.name)}}
+{{#var controllerFileName = generators.controllerFileName(entity.name)}}
+---
+to: {{ app.httpControllersPath(entity.path, controllerFileName) }}
+---
+import { HttpContext } from '@adonisjs/core/http'
+
+export default class {{ controllerName }} {
+  /**
+   * Display a list of resource
+   */
+  async index({}: HttpContext) {}
+
+  /**
+   * Display form to create a new record
+   */
+  async create({}: HttpContext) {}
+
+  /**
+   * Handle form submission for the create action
+   */
+  async store({ request }: HttpContext) {}
+
+  /**
+   * Show individual record
+   */
+  async show({ params }: HttpContext) {}
+
+  /**
+   * Edit individual record
+   */
+  async edit({ params }: HttpContext) {}
+
+  /**
+   * Handle form submission for the edit action
+   */
+  async update({ params, request }: HttpContext) {}
+
+  /**
+   * Delete record
+   */
+  async destroy({ params }: HttpContext) {}
+}

package/build/stubs/make/event/main.stub

@@ -0,0 +1,15 @@
+{{#var eventName = generators.eventName(entity.name)}}
+{{#var eventFileName = generators.eventFileName(entity.name)}}
+---
+to: {{ app.eventsPath(entity.path, eventFileName) }}
+---
+import { BaseEvent } from '@adonisjs/core/events'
+
+export default class {{ eventName }} extends BaseEvent {
+  /**
+   * Accept event data as constructor parameters
+   */
+  constructor() {
+    super()
+  }
+}

package/build/stubs/make/listener/for_event.stub

@@ -0,0 +1,13 @@
+{{#var listenerName = generators.listenerName(entity.name)}}
+{{#var listenerFileName = generators.listenerFileName(entity.name)}}
+{{#var eventName = generators.eventName(event.name)}}
+{{#var eventFileName = generators.eventFileName(event.name)}}
+{{#var eventImportPath = generators.importPath('#events', event.path, eventFileName)}}
+---
+to: {{ app.listenersPath(entity.path, listenerFileName) }}
+---
+import {{ eventName }} from '{{ eventImportPath }}'
+
+export default class {{ listenerName }} {
+  async handle(event: {{ eventName }}) {}
+}

package/build/stubs/make/listener/main.stub

@@ -0,0 +1,7 @@
+{{#var listenerName = generators.listenerName(entity.name)}}
+{{#var listenerFileName = generators.listenerFileName(entity.name)}}
+---
+to: {{ app.listenersPath(entity.path, listenerFileName) }}
+---
+export default class {{ listenerName }} {
+}

package/build/stubs/make/middleware/main.stub

@@ -0,0 +1,22 @@
+{{#var middlewareName = generators.middlewareName(entity.name)}}
+{{#var middlewareFileName = generators.middlewareFileName(entity.name)}}
+---
+to: {{ app.middlewarePath(entity.path, middlewareFileName) }}
+---
+import { HttpContext } from '@adonisjs/core/http'
+import { NextFn } from '@adonisjs/core/types/http'
+
+export default class {{ middlewareName }} {
+  async handle(ctx: HttpContext, next: NextFn) {
+    /**
+     * Middleware logic goes here (before the next call)
+     */
+    console.log(ctx)
+
+    /**
+     * Call next method in the pipeline and return its output
+     */
+    const output = await next()
+    return output
+  }
+}

package/build/stubs/make/provider/main.stub

@@ -0,0 +1,35 @@
+{{#var providerName = generators.providerName(entity.name)}}
+{{#var providerFileName = generators.providerFileName(entity.name)}}
+---
+to: {{ app.providersPath(entity.path, providerFileName) }}
+---
+import { ApplicationService } from '@adonisjs/core/types'
+
+export default class {{ providerName }} {
+  constructor(protected app: ApplicationService) {}
+
+  /**
+   * Register bindings to the container
+   */
+  register() {}
+
+  /**
+   * The container bindings have booted
+   */
+  async boot() {}
+
+  /**
+   * The application has been booted
+   */
+  async start() {}
+
+  /**
+   * The process has been started
+   */
+  async ready() {}
+
+  /**
+   * Preparing to shutdown the app
+   */
+  async shutdown() {}
+}

package/build/types/ace.d.ts

@@ -0,0 +1,5 @@
+import type { CommandOptions as BaseCommandOptions } from '@adonisjs/ace/types';
+export type CommandOptions = BaseCommandOptions & {
+    startApp?: boolean;
+};
+export * from '@adonisjs/ace/types';

package/build/types/ace.js

@@ -0,0 +1 @@
+export * from '@adonisjs/ace/types';

package/build/types/app.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/application/types';

package/build/types/app.js

@@ -0,0 +1 @@
+export * from '@adonisjs/application/types';

package/build/types/bodyparser.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/bodyparser/types';

package/build/types/bodyparser.js

@@ -0,0 +1 @@
+export * from '@adonisjs/bodyparser/types';

package/build/types/container.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/fold/types';

package/build/types/container.js

@@ -0,0 +1 @@
+export * from '@adonisjs/fold/types';

package/build/types/encryption.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/encryption/types';

package/build/types/encryption.js

@@ -0,0 +1 @@
+export * from '@adonisjs/encryption/types';

package/build/types/events.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/events/types';

package/build/types/events.js

@@ -0,0 +1 @@
+export * from '@adonisjs/events/types';

package/build/types/hash.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/hash/types';

package/build/types/hash.js

@@ -0,0 +1 @@
+export * from '@adonisjs/hash/types';

package/build/types/http.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/http-server/types';

package/build/types/http.js

@@ -0,0 +1 @@
+export * from '@adonisjs/http-server/types';

package/build/types/logger.d.ts

@@ -0,0 +1 @@
+export * from '@adonisjs/logger/types';

package/build/types/logger.js

@@ -0,0 +1 @@
+export * from '@adonisjs/logger/types';