@fedify/adonisjs 2.4.0-dev.0

package/dist/src/define_config.d.cts

@@ -0,0 +1,30 @@
+import { FedifyConfig, ResolvedFedifyConfig } from "./types.cjs";
+import { ConfigProvider } from "@adonisjs/core/types";
+
+//#region src/define_config.d.ts
+/**
+* Defines the Fedify configuration of an AdonisJS application.
+*
+* The return value is an AdonisJS *config provider* rather than a plain object,
+* which lets the resolution step reach the application instance — needed to
+* detect production mode and to log through the application's logger — while
+* `config/fedify.ts` itself stays a simple, synchronous, statically analysable
+* module.
+*
+* @example
+* ```ts
+* // config/fedify.ts
+* import { defineConfig } from '@fedify/adonisjs'
+* import { SqliteKvStore } from '@fedify/sqlite'
+* import env from '#start/env'
+*
+* export default defineConfig({
+*   origin: env.get('PUBLIC_URL'),
+*   kv: new SqliteKvStore(database),
+* })
+* ```
+*/
+declare function defineConfig(config: FedifyConfig): ConfigProvider<ResolvedFedifyConfig>;
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=define_config.d.cts.map

package/dist/src/define_config.d.ts

@@ -0,0 +1,30 @@
+import { FedifyConfig, ResolvedFedifyConfig } from "./types.js";
+import { ConfigProvider } from "@adonisjs/core/types";
+
+//#region src/define_config.d.ts
+/**
+* Defines the Fedify configuration of an AdonisJS application.
+*
+* The return value is an AdonisJS *config provider* rather than a plain object,
+* which lets the resolution step reach the application instance — needed to
+* detect production mode and to log through the application's logger — while
+* `config/fedify.ts` itself stays a simple, synchronous, statically analysable
+* module.
+*
+* @example
+* ```ts
+* // config/fedify.ts
+* import { defineConfig } from '@fedify/adonisjs'
+* import { SqliteKvStore } from '@fedify/sqlite'
+* import env from '#start/env'
+*
+* export default defineConfig({
+*   origin: env.get('PUBLIC_URL'),
+*   kv: new SqliteKvStore(database),
+* })
+* ```
+*/
+declare function defineConfig(config: FedifyConfig): ConfigProvider<ResolvedFedifyConfig>;
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=define_config.d.ts.map

package/dist/src/define_config.js

@@ -0,0 +1,113 @@
+import { configProvider } from "@adonisjs/core";
+import { InvalidArgumentsException } from "@adonisjs/core/exceptions";
+
+//#region src/define_config.ts
+/**
+* The `defineConfig` helper used by `config/fedify.ts`.
+*
+* @module
+*/
+/**
+* Whether the `queue` option carries a queue at all.
+*
+* `FederationOptions.queue` takes either one `MessageQueue` for every role or
+* an object of per-role queues, and Fedify reads an object whose members are
+* all `undefined` as no queue.  Testing the option's presence would therefore
+* misfire in both directions: `queue: { outbox: app.inProduction ? q :
+* undefined }` looks configured in development, and `queue: {}` looks like a
+* queue that needs draining.
+*/
+function hasQueue(queue) {
+	if (queue == null) return false;
+	if ("enqueue" in queue && "listen" in queue) return true;
+	return Object.values(queue).some((role) => role != null);
+}
+/**
+* Defines the Fedify configuration of an AdonisJS application.
+*
+* The return value is an AdonisJS *config provider* rather than a plain object,
+* which lets the resolution step reach the application instance — needed to
+* detect production mode and to log through the application's logger — while
+* `config/fedify.ts` itself stays a simple, synchronous, statically analysable
+* module.
+*
+* @example
+* ```ts
+* // config/fedify.ts
+* import { defineConfig } from '@fedify/adonisjs'
+* import { SqliteKvStore } from '@fedify/sqlite'
+* import env from '#start/env'
+*
+* export default defineConfig({
+*   origin: env.get('PUBLIC_URL'),
+*   kv: new SqliteKvStore(database),
+* })
+* ```
+*/
+function defineConfig(config) {
+	return configProvider.create(async (app) => {
+		if (!config.origin) {
+			throw new InvalidArgumentsException("Missing \"origin\" in config/fedify.ts. It must be the canonical public URL of this server, " + "usually read from the PUBLIC_URL environment variable");
+		}
+		let kv = config.kv;
+		if (kv === undefined) {
+			const { MemoryKvStore } = await import("@fedify/fedify");
+			kv = new MemoryKvStore();
+			if (app.inProduction) {
+				const logger = await app.container.make("logger");
+				logger.warn("Fedify is using an in-memory key-value store in production. Inbox idempotency, " + "the document cache and outbox state will be lost on restart and cannot be shared " + "between processes. Configure \"kv\" in config/fedify.ts with a persistent store such " + "as @fedify/sqlite, @fedify/postgres or @fedify/redis");
+			}
+		}
+		const { contextDataFactory, ignoreRoutePrefixes, logging, queueContextData, ...federationOptions } = config;
+		/**
+		* A configured queue forces the "who drains it" decision to be explicit.
+		*
+		* Fedify's own default starts the queue lazily on the first enqueued task,
+		* capturing that request's context data and reusing it for every background
+		* job thereafter. For this integration the captured value would be a single
+		* stale `HttpContext`, whose request has long since finished. Rather than
+		* pick a wrong default, refuse to guess.
+		*/
+		if (hasQueue(federationOptions.queue) && queueContextData === undefined) {
+			throw new InvalidArgumentsException("config/fedify.ts configures a \"queue\" but not \"queueContextData\". Set " + "\"queueContextData\" to a callback to have this process drain the queue, or to " + "\"false\" when a separate worker process owns it");
+		}
+		/**
+		* The mirror image: a drainer for a queue that does not exist.  Nothing
+		* fails on its own — `startQueue()` resolves over no queues and
+		* `sendActivity()` delivers inline without retry, so failed deliveries are
+		* silently lost.
+		*
+		* Only a warning, because a task registered with
+		* `defineTask(name, { queue })` from a preload file brings its own queue,
+		* which this configuration cannot see.  Refusing would break a valid
+		* application, and dropping the callback would hand that queue back to
+		* Fedify's lazy start.  Only a *callback* is reported: `false` stays valid
+		* without a queue, so `queue: app.inProduction ? … : undefined` still
+		* boots in development and test.
+		*/
+		if (!hasQueue(federationOptions.queue) && typeof queueContextData === "function") {
+			const logger = await app.container.make("logger");
+			logger.warn("config/fedify.ts sets \"queueContextData\" but no \"queue\". Unless a task registers its own " + "queue through defineTask(), there is nothing to drain and activity delivery stays " + "inline, with failed deliveries never retried. Configure \"queue\" with a message queue " + "such as @fedify/sqlite, @fedify/postgres, @fedify/redis or @fedify/amqp, or remove " + "\"queueContextData\"");
+		}
+		return {
+			...federationOptions,
+			kv,
+			manuallyStartQueue: queueContextData !== undefined ? true : config.manuallyStartQueue,
+			/**
+			* The cast is sound because `ContextDataFactoryOption` makes
+			* `contextDataFactory` a *required* key the moment an application
+			* augments `FedifyTypes`.  This branch is therefore only reachable while
+			* `ContextData` still includes `HttpContext`, which is exactly what it
+			* returns.
+			*/
+			contextDataFactory: contextDataFactory ?? ((ctx) => ctx),
+			ignoreRoutePrefixes: ignoreRoutePrefixes ?? [],
+			logging: logging ?? true,
+			queueContextData
+		};
+	});
+}
+
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=define_config.js.map

package/dist/src/define_config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define_config.js","names":[],"sources":["../../src/define_config.ts"],"sourcesContent":["/**\n * The `defineConfig` helper used by `config/fedify.ts`.\n *\n * @module\n */\nimport { configProvider } from \"@adonisjs/core\";\nimport { InvalidArgumentsException } from \"@adonisjs/core/exceptions\";\nimport type { ConfigProvider } from \"@adonisjs/core/types\";\nimport type { FederationOptions } from \"@fedify/fedify\";\n\nimport type {\n  ContextData,\n  FedifyConfig,\n  ResolvedFedifyConfig,\n} from \"./types.ts\";\n\n/**\n * Whether the `queue` option carries a queue at all.\n *\n * `FederationOptions.queue` takes either one `MessageQueue` for every role or\n * an object of per-role queues, and Fedify reads an object whose members are\n * all `undefined` as no queue.  Testing the option's presence would therefore\n * misfire in both directions: `queue: { outbox: app.inProduction ? q :\n * undefined }` looks configured in development, and `queue: {}` looks like a\n * queue that needs draining.\n */\nfunction hasQueue(queue: FederationOptions<unknown>[\"queue\"]): boolean {\n  if (queue == null) return false;\n  if (\"enqueue\" in queue && \"listen\" in queue) return true;\n  return Object.values(queue).some((role) => role != null);\n}\n\n/**\n * Defines the Fedify configuration of an AdonisJS application.\n *\n * The return value is an AdonisJS *config provider* rather than a plain object,\n * which lets the resolution step reach the application instance — needed to\n * detect production mode and to log through the application's logger — while\n * `config/fedify.ts` itself stays a simple, synchronous, statically analysable\n * module.\n *\n * @example\n * ```ts\n * // config/fedify.ts\n * import { defineConfig } from '@fedify/adonisjs'\n * import { SqliteKvStore } from '@fedify/sqlite'\n * import env from '#start/env'\n *\n * export default defineConfig({\n *   origin: env.get('PUBLIC_URL'),\n *   kv: new SqliteKvStore(database),\n * })\n * ```\n */\nexport function defineConfig(\n  config: FedifyConfig,\n): ConfigProvider<ResolvedFedifyConfig> {\n  return configProvider.create<ResolvedFedifyConfig>(async (app) => {\n    if (!config.origin) {\n      throw new InvalidArgumentsException(\n        'Missing \"origin\" in config/fedify.ts. It must be the canonical public URL of this server, ' +\n          \"usually read from the PUBLIC_URL environment variable\",\n      );\n    }\n\n    let kv = config.kv;\n    if (kv === undefined) {\n      const { MemoryKvStore } = await import(\"@fedify/fedify\");\n      kv = new MemoryKvStore();\n\n      if (app.inProduction) {\n        // Not fatal — an application may genuinely run a single process and\n        // accept the trade-off — but silently losing inbox idempotency and the\n        // document cache on every restart is worth shouting about.\n        const logger = await app.container.make(\"logger\");\n        logger.warn(\n          \"Fedify is using an in-memory key-value store in production. Inbox idempotency, \" +\n            \"the document cache and outbox state will be lost on restart and cannot be shared \" +\n            'between processes. Configure \"kv\" in config/fedify.ts with a persistent store such ' +\n            \"as @fedify/sqlite, @fedify/postgres or @fedify/redis\",\n        );\n      }\n    }\n\n    const {\n      contextDataFactory,\n      ignoreRoutePrefixes,\n      logging,\n      queueContextData,\n      ...federationOptions\n    } = config;\n\n    /**\n     * A configured queue forces the \"who drains it\" decision to be explicit.\n     *\n     * Fedify's own default starts the queue lazily on the first enqueued task,\n     * capturing that request's context data and reusing it for every background\n     * job thereafter. For this integration the captured value would be a single\n     * stale `HttpContext`, whose request has long since finished. Rather than\n     * pick a wrong default, refuse to guess.\n     */\n    if (hasQueue(federationOptions.queue) && queueContextData === undefined) {\n      throw new InvalidArgumentsException(\n        'config/fedify.ts configures a \"queue\" but not \"queueContextData\". Set ' +\n          '\"queueContextData\" to a callback to have this process drain the queue, or to ' +\n          '\"false\" when a separate worker process owns it',\n      );\n    }\n\n    /**\n     * The mirror image: a drainer for a queue that does not exist.  Nothing\n     * fails on its own — `startQueue()` resolves over no queues and\n     * `sendActivity()` delivers inline without retry, so failed deliveries are\n     * silently lost.\n     *\n     * Only a warning, because a task registered with\n     * `defineTask(name, { queue })` from a preload file brings its own queue,\n     * which this configuration cannot see.  Refusing would break a valid\n     * application, and dropping the callback would hand that queue back to\n     * Fedify's lazy start.  Only a *callback* is reported: `false` stays valid\n     * without a queue, so `queue: app.inProduction ? … : undefined` still\n     * boots in development and test.\n     */\n    if (\n      !hasQueue(federationOptions.queue) &&\n      typeof queueContextData === \"function\"\n    ) {\n      const logger = await app.container.make(\"logger\");\n      logger.warn(\n        'config/fedify.ts sets \"queueContextData\" but no \"queue\". Unless a task registers its own ' +\n          \"queue through defineTask(), there is nothing to drain and activity delivery stays \" +\n          'inline, with failed deliveries never retried. Configure \"queue\" with a message queue ' +\n          \"such as @fedify/sqlite, @fedify/postgres, @fedify/redis or @fedify/amqp, or remove \" +\n          '\"queueContextData\"',\n      );\n    }\n\n    return {\n      ...federationOptions,\n      kv,\n\n      // The queue is always started deliberately — by this package's service\n      // provider, or by a separate worker — never lazily by Fedify.\n      manuallyStartQueue: queueContextData !== undefined\n        ? true\n        : config.manuallyStartQueue,\n\n      /**\n       * The cast is sound because `ContextDataFactoryOption` makes\n       * `contextDataFactory` a *required* key the moment an application\n       * augments `FedifyTypes`.  This branch is therefore only reachable while\n       * `ContextData` still includes `HttpContext`, which is exactly what it\n       * returns.\n       */\n      contextDataFactory: contextDataFactory ?? ((ctx) => ctx as ContextData),\n      ignoreRoutePrefixes: ignoreRoutePrefixes ?? [],\n      logging: logging ?? true,\n      queueContextData,\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,SAAS,SAAS,OAAqD;CACrE,IAAI,SAAS,MAAM,OAAO;CAC1B,IAAI,aAAa,SAAS,YAAY,OAAO,OAAO;CACpD,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM,SAAS,QAAQ,IAAI;AACzD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,aACd,QACsC;CACtC,OAAO,eAAe,OAA6B,OAAO,QAAQ;EAChE,IAAI,CAAC,OAAO,QAAQ;GAClB,MAAM,IAAI,0BACR,iGACE,uDACJ;EACF;EAEA,IAAI,KAAK,OAAO;EAChB,IAAI,OAAO,WAAW;GACpB,MAAM,EAAE,kBAAkB,MAAM,OAAO;GACvC,KAAK,IAAI,cAAc;GAEvB,IAAI,IAAI,cAAc;IAIpB,MAAM,SAAS,MAAM,IAAI,UAAU,KAAK,QAAQ;IAChD,OAAO,KACL,oFACE,sFACA,0FACA,sDACJ;GACF;EACF;EAEA,MAAM,EACJ,oBACA,qBACA,SACA,kBACA,GAAG,sBACD;;;;;;;;;;EAWJ,IAAI,SAAS,kBAAkB,KAAK,KAAK,qBAAqB,WAAW;GACvE,MAAM,IAAI,0BACR,+EACE,oFACA,kDACJ;EACF;;;;;;;;;;;;;;;EAgBA,IACE,CAAC,SAAS,kBAAkB,KAAK,KACjC,OAAO,qBAAqB,YAC5B;GACA,MAAM,SAAS,MAAM,IAAI,UAAU,KAAK,QAAQ;GAChD,OAAO,KACL,kGACE,uFACA,4FACA,wFACA,sBACJ;EACF;EAEA,OAAO;GACL,GAAG;GACH;GAIA,oBAAoB,qBAAqB,YACrC,OACA,OAAO;;;;;;;;GASX,oBAAoB,wBAAwB,QAAQ;GACpD,qBAAqB,uBAAuB,CAAC;GAC7C,SAAS,WAAW;GACpB;EACF;CACF,CAAC;AACH"}

package/dist/src/errors.cjs

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _adonisjs_core_exceptions = require("@adonisjs/core/exceptions");
+
+//#region src/errors.ts
+/**
+* Exceptions raised by `@fedify/adonisjs`.
+*
+* They extend AdonisJS's `Exception` base class, so applications can match on
+* `error.code` and the framework's exception handler renders them with the
+* right HTTP status.
+*
+* Every message says what to do about the problem rather than only what went
+* wrong: all three of these are configuration and lifecycle mistakes whose
+* natural symptom would otherwise be a silent 404 from every federation
+* endpoint.
+*
+* @module
+*/
+/**
+* Raised when `config/fedify.ts` is missing, or does not export the result of
+* `defineConfig()`.
+*/
+var E_INVALID_FEDIFY_CONFIG = class extends _adonisjs_core_exceptions.Exception {
+	static code = "E_INVALID_FEDIFY_CONFIG";
+	static status = 500;
+	static message = "Invalid \"config/fedify.ts\" file. Make sure to export the return value of the \"defineConfig\" method";
+};
+/**
+* Raised when the `Federation` instance is resolved from the container before
+* the application has finished booting.
+*
+* Dispatchers are registered on the `FederationBuilder` by preload files, and
+* the builder can only be turned into a `Federation` once every preload has
+* run.  Resolving `'fedify'` earlier would silently produce a `Federation` with
+* no routes at all, which is far harder to debug than an explicit error.
+*/
+var E_FEDERATION_NOT_READY = class extends _adonisjs_core_exceptions.Exception {
+	static code = "E_FEDERATION_NOT_READY";
+	static status = 500;
+	static message = "The Federation instance is not available yet. It is built after the application boots, so it cannot be resolved from a service provider's register or boot method. Use \"ctx.federation\" inside HTTP requests, the \"Context\" argument inside dispatchers, or resolve it with \"app.container.make('fedify')\" from code that runs once the application is ready";
+};
+/**
+* Raised when `FedifyMiddleware` is constructed without a `Federation`.
+*
+* The container falls back to a zero-argument construction when the class it
+* resolves is not the object the provider bound — a duplicated copy of this
+* package in the dependency tree, or its ESM and CJS builds mixed in one
+* process.  Failing at construction with an actionable message beats the
+* `TypeError` every request would otherwise throw.
+*
+* The `fedifyMiddleware()` factory raises it too, with a message of its own,
+* when it is called without a `Federation` — typically an import from a
+* module that does not default-export one.
+*/
+var E_MISSING_FEDERATION = class extends _adonisjs_core_exceptions.Exception {
+	static code = "E_MISSING_FEDERATION";
+	static status = 500;
+	static message = "FedifyMiddleware was constructed without a Federation instance. Register \"@fedify/adonisjs/fedify_provider\" so the container binding supplies it, or build the middleware with the \"fedifyMiddleware\" factory. If the provider is registered, this process is loading two copies of \"@fedify/adonisjs\" (for example its ESM and CJS builds), so the class the kernel resolved is not the one the provider bound";
+};
+/**
+* Raised when `ctx.federation` is accessed on a request the Fedify middleware
+* deliberately skipped, or on a request it never saw at all.
+*/
+var E_FEDIFY_CONTEXT_UNAVAILABLE = class extends _adonisjs_core_exceptions.Exception {
+	static code = "E_FEDIFY_CONTEXT_UNAVAILABLE";
+	static status = 500;
+	constructor(path) {
+		super(`Cannot access "ctx.federation" for "${path}". Either the request path matches "ignoreRoutePrefixes" in config/fedify.ts, the request method is one the Fetch API cannot represent (CONNECT, TRACE, TRACK), or the Fedify middleware is not registered in the server middleware stack of start/kernel.ts`);
+	}
+};
+
+//#endregion
+exports.E_FEDERATION_NOT_READY = E_FEDERATION_NOT_READY;
+exports.E_FEDIFY_CONTEXT_UNAVAILABLE = E_FEDIFY_CONTEXT_UNAVAILABLE;
+exports.E_INVALID_FEDIFY_CONFIG = E_INVALID_FEDIFY_CONFIG;
+exports.E_MISSING_FEDERATION = E_MISSING_FEDERATION;
+//# sourceMappingURL=errors.cjs.map

package/dist/src/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","names":["Exception"],"sources":["../../src/errors.ts"],"sourcesContent":["/**\n * Exceptions raised by `@fedify/adonisjs`.\n *\n * They extend AdonisJS's `Exception` base class, so applications can match on\n * `error.code` and the framework's exception handler renders them with the\n * right HTTP status.\n *\n * Every message says what to do about the problem rather than only what went\n * wrong: all three of these are configuration and lifecycle mistakes whose\n * natural symptom would otherwise be a silent 404 from every federation\n * endpoint.\n *\n * @module\n */\nimport { Exception } from \"@adonisjs/core/exceptions\";\n\n/**\n * Raised when `config/fedify.ts` is missing, or does not export the result of\n * `defineConfig()`.\n */\nexport class E_INVALID_FEDIFY_CONFIG extends Exception {\n  static override code = \"E_INVALID_FEDIFY_CONFIG\";\n  static override status = 500;\n  static override message =\n    'Invalid \"config/fedify.ts\" file. Make sure to export the return value of the \"defineConfig\" method';\n}\n\n/**\n * Raised when the `Federation` instance is resolved from the container before\n * the application has finished booting.\n *\n * Dispatchers are registered on the `FederationBuilder` by preload files, and\n * the builder can only be turned into a `Federation` once every preload has\n * run.  Resolving `'fedify'` earlier would silently produce a `Federation` with\n * no routes at all, which is far harder to debug than an explicit error.\n */\nexport class E_FEDERATION_NOT_READY extends Exception {\n  static override code = \"E_FEDERATION_NOT_READY\";\n  static override status = 500;\n  static override message =\n    'The Federation instance is not available yet. It is built after the application boots, so it cannot be resolved from a service provider\\'s register or boot method. Use \"ctx.federation\" inside HTTP requests, the \"Context\" argument inside dispatchers, or resolve it with \"app.container.make(\\'fedify\\')\" from code that runs once the application is ready';\n}\n\n/**\n * Raised when `FedifyMiddleware` is constructed without a `Federation`.\n *\n * The container falls back to a zero-argument construction when the class it\n * resolves is not the object the provider bound — a duplicated copy of this\n * package in the dependency tree, or its ESM and CJS builds mixed in one\n * process.  Failing at construction with an actionable message beats the\n * `TypeError` every request would otherwise throw.\n *\n * The `fedifyMiddleware()` factory raises it too, with a message of its own,\n * when it is called without a `Federation` — typically an import from a\n * module that does not default-export one.\n */\nexport class E_MISSING_FEDERATION extends Exception {\n  static override code = \"E_MISSING_FEDERATION\";\n  static override status = 500;\n  static override message =\n    'FedifyMiddleware was constructed without a Federation instance. Register \"@fedify/adonisjs/fedify_provider\" so the container binding supplies it, or build the middleware with the \"fedifyMiddleware\" factory. If the provider is registered, this process is loading two copies of \"@fedify/adonisjs\" (for example its ESM and CJS builds), so the class the kernel resolved is not the one the provider bound';\n}\n\n/**\n * Raised when `ctx.federation` is accessed on a request the Fedify middleware\n * deliberately skipped, or on a request it never saw at all.\n */\nexport class E_FEDIFY_CONTEXT_UNAVAILABLE extends Exception {\n  static override code = \"E_FEDIFY_CONTEXT_UNAVAILABLE\";\n  static override status = 500;\n\n  constructor(path: string) {\n    super(\n      `Cannot access \"ctx.federation\" for \"${path}\". Either the request path matches \"ignoreRoutePrefixes\" in config/fedify.ts, the request method is one the Fetch API cannot represent (CONNECT, TRACE, TRACK), or the Fedify middleware is not registered in the server middleware stack of start/kernel.ts`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,0BAAb,cAA6CA,oCAAU;CACrD,OAAgB,OAAO;CACvB,OAAgB,SAAS;CACzB,OAAgB,UACd;AACJ;;;;;;;;;;AAWA,IAAa,yBAAb,cAA4CA,oCAAU;CACpD,OAAgB,OAAO;CACvB,OAAgB,SAAS;CACzB,OAAgB,UACd;AACJ;;;;;;;;;;;;;;AAeA,IAAa,uBAAb,cAA0CA,oCAAU;CAClD,OAAgB,OAAO;CACvB,OAAgB,SAAS;CACzB,OAAgB,UACd;AACJ;;;;;AAMA,IAAa,+BAAb,cAAkDA,oCAAU;CAC1D,OAAgB,OAAO;CACvB,OAAgB,SAAS;CAEzB,YAAY,MAAc;EACxB,MACE,uCAAuC,KAAK,6PAC9C;CACF;AACF"}

package/dist/src/errors.d.cts

@@ -0,0 +1,56 @@
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/errors.d.ts
+/**
+* Raised when `config/fedify.ts` is missing, or does not export the result of
+* `defineConfig()`.
+*/
+declare class E_INVALID_FEDIFY_CONFIG extends Exception {
+  static override code: string;
+  static override status: number;
+  static override message: string;
+}
+/**
+* Raised when the `Federation` instance is resolved from the container before
+* the application has finished booting.
+*
+* Dispatchers are registered on the `FederationBuilder` by preload files, and
+* the builder can only be turned into a `Federation` once every preload has
+* run.  Resolving `'fedify'` earlier would silently produce a `Federation` with
+* no routes at all, which is far harder to debug than an explicit error.
+*/
+declare class E_FEDERATION_NOT_READY extends Exception {
+  static override code: string;
+  static override status: number;
+  static override message: string;
+}
+/**
+* Raised when `FedifyMiddleware` is constructed without a `Federation`.
+*
+* The container falls back to a zero-argument construction when the class it
+* resolves is not the object the provider bound — a duplicated copy of this
+* package in the dependency tree, or its ESM and CJS builds mixed in one
+* process.  Failing at construction with an actionable message beats the
+* `TypeError` every request would otherwise throw.
+*
+* The `fedifyMiddleware()` factory raises it too, with a message of its own,
+* when it is called without a `Federation` — typically an import from a
+* module that does not default-export one.
+*/
+declare class E_MISSING_FEDERATION extends Exception {
+  static override code: string;
+  static override status: number;
+  static override message: string;
+}
+/**
+* Raised when `ctx.federation` is accessed on a request the Fedify middleware
+* deliberately skipped, or on a request it never saw at all.
+*/
+declare class E_FEDIFY_CONTEXT_UNAVAILABLE extends Exception {
+  static override code: string;
+  static override status: number;
+  constructor(path: string);
+}
+//#endregion
+export { E_FEDERATION_NOT_READY, E_FEDIFY_CONTEXT_UNAVAILABLE, E_INVALID_FEDIFY_CONFIG, E_MISSING_FEDERATION };
+//# sourceMappingURL=errors.d.cts.map

package/dist/src/errors.d.ts

@@ -0,0 +1,56 @@
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/errors.d.ts
+/**
+* Raised when `config/fedify.ts` is missing, or does not export the result of
+* `defineConfig()`.
+*/
+declare class E_INVALID_FEDIFY_CONFIG extends Exception {
+  static override code: string;
+  static override status: number;
+  static override message: string;
+}
+/**
+* Raised when the `Federation` instance is resolved from the container before
+* the application has finished booting.
+*
+* Dispatchers are registered on the `FederationBuilder` by preload files, and
+* the builder can only be turned into a `Federation` once every preload has
+* run.  Resolving `'fedify'` earlier would silently produce a `Federation` with
+* no routes at all, which is far harder to debug than an explicit error.
+*/
+declare class E_FEDERATION_NOT_READY extends Exception {
+  static override code: string;
+  static override status: number;
+  static override message: string;
+}
+/**
+* Raised when `FedifyMiddleware` is constructed without a `Federation`.
+*
+* The container falls back to a zero-argument construction when the class it
+* resolves is not the object the provider bound — a duplicated copy of this
+* package in the dependency tree, or its ESM and CJS builds mixed in one
+* process.  Failing at construction with an actionable message beats the
+* `TypeError` every request would otherwise throw.
+*
+* The `fedifyMiddleware()` factory raises it too, with a message of its own,
+* when it is called without a `Federation` — typically an import from a
+* module that does not default-export one.
+*/
+declare class E_MISSING_FEDERATION extends Exception {
+  static override code: string;
+  static override status: number;
+  static override message: string;
+}
+/**
+* Raised when `ctx.federation` is accessed on a request the Fedify middleware
+* deliberately skipped, or on a request it never saw at all.
+*/
+declare class E_FEDIFY_CONTEXT_UNAVAILABLE extends Exception {
+  static override code: string;
+  static override status: number;
+  constructor(path: string);
+}
+//#endregion
+export { E_FEDERATION_NOT_READY, E_FEDIFY_CONTEXT_UNAVAILABLE, E_INVALID_FEDIFY_CONFIG, E_MISSING_FEDERATION };
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,73 @@
+import { Exception } from "@adonisjs/core/exceptions";
+
+//#region src/errors.ts
+/**
+* Exceptions raised by `@fedify/adonisjs`.
+*
+* They extend AdonisJS's `Exception` base class, so applications can match on
+* `error.code` and the framework's exception handler renders them with the
+* right HTTP status.
+*
+* Every message says what to do about the problem rather than only what went
+* wrong: all three of these are configuration and lifecycle mistakes whose
+* natural symptom would otherwise be a silent 404 from every federation
+* endpoint.
+*
+* @module
+*/
+/**
+* Raised when `config/fedify.ts` is missing, or does not export the result of
+* `defineConfig()`.
+*/
+var E_INVALID_FEDIFY_CONFIG = class extends Exception {
+	static code = "E_INVALID_FEDIFY_CONFIG";
+	static status = 500;
+	static message = "Invalid \"config/fedify.ts\" file. Make sure to export the return value of the \"defineConfig\" method";
+};
+/**
+* Raised when the `Federation` instance is resolved from the container before
+* the application has finished booting.
+*
+* Dispatchers are registered on the `FederationBuilder` by preload files, and
+* the builder can only be turned into a `Federation` once every preload has
+* run.  Resolving `'fedify'` earlier would silently produce a `Federation` with
+* no routes at all, which is far harder to debug than an explicit error.
+*/
+var E_FEDERATION_NOT_READY = class extends Exception {
+	static code = "E_FEDERATION_NOT_READY";
+	static status = 500;
+	static message = "The Federation instance is not available yet. It is built after the application boots, so it cannot be resolved from a service provider's register or boot method. Use \"ctx.federation\" inside HTTP requests, the \"Context\" argument inside dispatchers, or resolve it with \"app.container.make('fedify')\" from code that runs once the application is ready";
+};
+/**
+* Raised when `FedifyMiddleware` is constructed without a `Federation`.
+*
+* The container falls back to a zero-argument construction when the class it
+* resolves is not the object the provider bound — a duplicated copy of this
+* package in the dependency tree, or its ESM and CJS builds mixed in one
+* process.  Failing at construction with an actionable message beats the
+* `TypeError` every request would otherwise throw.
+*
+* The `fedifyMiddleware()` factory raises it too, with a message of its own,
+* when it is called without a `Federation` — typically an import from a
+* module that does not default-export one.
+*/
+var E_MISSING_FEDERATION = class extends Exception {
+	static code = "E_MISSING_FEDERATION";
+	static status = 500;
+	static message = "FedifyMiddleware was constructed without a Federation instance. Register \"@fedify/adonisjs/fedify_provider\" so the container binding supplies it, or build the middleware with the \"fedifyMiddleware\" factory. If the provider is registered, this process is loading two copies of \"@fedify/adonisjs\" (for example its ESM and CJS builds), so the class the kernel resolved is not the one the provider bound";
+};
+/**
+* Raised when `ctx.federation` is accessed on a request the Fedify middleware
+* deliberately skipped, or on a request it never saw at all.
+*/
+var E_FEDIFY_CONTEXT_UNAVAILABLE = class extends Exception {
+	static code = "E_FEDIFY_CONTEXT_UNAVAILABLE";
+	static status = 500;
+	constructor(path) {
+		super(`Cannot access "ctx.federation" for "${path}". Either the request path matches "ignoreRoutePrefixes" in config/fedify.ts, the request method is one the Fetch API cannot represent (CONNECT, TRACE, TRACK), or the Fedify middleware is not registered in the server middleware stack of start/kernel.ts`);
+	}
+};
+
+//#endregion
+export { E_FEDERATION_NOT_READY, E_FEDIFY_CONTEXT_UNAVAILABLE, E_INVALID_FEDIFY_CONFIG, E_MISSING_FEDERATION };
+//# sourceMappingURL=errors.js.map

package/dist/src/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/errors.ts"],"sourcesContent":["/**\n * Exceptions raised by `@fedify/adonisjs`.\n *\n * They extend AdonisJS's `Exception` base class, so applications can match on\n * `error.code` and the framework's exception handler renders them with the\n * right HTTP status.\n *\n * Every message says what to do about the problem rather than only what went\n * wrong: all three of these are configuration and lifecycle mistakes whose\n * natural symptom would otherwise be a silent 404 from every federation\n * endpoint.\n *\n * @module\n */\nimport { Exception } from \"@adonisjs/core/exceptions\";\n\n/**\n * Raised when `config/fedify.ts` is missing, or does not export the result of\n * `defineConfig()`.\n */\nexport class E_INVALID_FEDIFY_CONFIG extends Exception {\n  static override code = \"E_INVALID_FEDIFY_CONFIG\";\n  static override status = 500;\n  static override message =\n    'Invalid \"config/fedify.ts\" file. Make sure to export the return value of the \"defineConfig\" method';\n}\n\n/**\n * Raised when the `Federation` instance is resolved from the container before\n * the application has finished booting.\n *\n * Dispatchers are registered on the `FederationBuilder` by preload files, and\n * the builder can only be turned into a `Federation` once every preload has\n * run.  Resolving `'fedify'` earlier would silently produce a `Federation` with\n * no routes at all, which is far harder to debug than an explicit error.\n */\nexport class E_FEDERATION_NOT_READY extends Exception {\n  static override code = \"E_FEDERATION_NOT_READY\";\n  static override status = 500;\n  static override message =\n    'The Federation instance is not available yet. It is built after the application boots, so it cannot be resolved from a service provider\\'s register or boot method. Use \"ctx.federation\" inside HTTP requests, the \"Context\" argument inside dispatchers, or resolve it with \"app.container.make(\\'fedify\\')\" from code that runs once the application is ready';\n}\n\n/**\n * Raised when `FedifyMiddleware` is constructed without a `Federation`.\n *\n * The container falls back to a zero-argument construction when the class it\n * resolves is not the object the provider bound — a duplicated copy of this\n * package in the dependency tree, or its ESM and CJS builds mixed in one\n * process.  Failing at construction with an actionable message beats the\n * `TypeError` every request would otherwise throw.\n *\n * The `fedifyMiddleware()` factory raises it too, with a message of its own,\n * when it is called without a `Federation` — typically an import from a\n * module that does not default-export one.\n */\nexport class E_MISSING_FEDERATION extends Exception {\n  static override code = \"E_MISSING_FEDERATION\";\n  static override status = 500;\n  static override message =\n    'FedifyMiddleware was constructed without a Federation instance. Register \"@fedify/adonisjs/fedify_provider\" so the container binding supplies it, or build the middleware with the \"fedifyMiddleware\" factory. If the provider is registered, this process is loading two copies of \"@fedify/adonisjs\" (for example its ESM and CJS builds), so the class the kernel resolved is not the one the provider bound';\n}\n\n/**\n * Raised when `ctx.federation` is accessed on a request the Fedify middleware\n * deliberately skipped, or on a request it never saw at all.\n */\nexport class E_FEDIFY_CONTEXT_UNAVAILABLE extends Exception {\n  static override code = \"E_FEDIFY_CONTEXT_UNAVAILABLE\";\n  static override status = 500;\n\n  constructor(path: string) {\n    super(\n      `Cannot access \"ctx.federation\" for \"${path}\". Either the request path matches \"ignoreRoutePrefixes\" in config/fedify.ts, the request method is one the Fetch API cannot represent (CONNECT, TRACE, TRACK), or the Fedify middleware is not registered in the server middleware stack of start/kernel.ts`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,0BAAb,cAA6C,UAAU;CACrD,OAAgB,OAAO;CACvB,OAAgB,SAAS;CACzB,OAAgB,UACd;AACJ;;;;;;;;;;AAWA,IAAa,yBAAb,cAA4C,UAAU;CACpD,OAAgB,OAAO;CACvB,OAAgB,SAAS;CACzB,OAAgB,UACd;AACJ;;;;;;;;;;;;;;AAeA,IAAa,uBAAb,cAA0C,UAAU;CAClD,OAAgB,OAAO;CACvB,OAAgB,SAAS;CACzB,OAAgB,UACd;AACJ;;;;;AAMA,IAAa,+BAAb,cAAkD,UAAU;CAC1D,OAAgB,OAAO;CACvB,OAAgB,SAAS;CAEzB,YAAY,MAAc;EACxB,MACE,uCAAuC,KAAK,6PAC9C;CACF;AACF"}