lumen-framework 3.1.1 → 4.0.0

package/dist/types/packages/cli/generator/utils/migration-conflict.d.ts

@@ -1,6 +1,6 @@
-import type { Generator$opts } from '../index';
+import type { GeneratorOptions } from '../index';
 export declare function detectConflict(path: string): Promise<boolean>;
 export declare function createConflictResolver({ cwd, onConflict }: {
-    cwd: Generator$opts['cwd'];
-    onConflict: Generator$opts['onConflict'];
-}): Generator$opts['onConflict'];
+    cwd: GeneratorOptions['cwd'];
+    onConflict: GeneratorOptions['onConflict'];
+}): GeneratorOptions['onConflict'];

package/dist/types/packages/cli/templates/pnpm-workspace.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `pnpm-workspace.yaml` of a new app. pnpm 12 fails an install over a
+ * dependency's build script it was not told to run or skip, and reads that
+ * from this file only. npm ignores it.
+ *
+ * - esbuild (a dependency of lumen-framework): its postinstall only links its
+ *   platform binary over the `esbuild` command; the app compiler uses its
+ *   JavaScript API, which finds the binary itself.
+ * - better-sqlite3 ships prebuilt binaries for every platform it supports, but
+ *   pnpm would run `node-gyp rebuild` for its `binding.gyp`.
+ *
+ * @private
+ */
+declare const _default: (driver: string) => string;
+export default _default;

package/dist/types/packages/cli/utils/create-spinner.d.ts

@@ -0,0 +1,14 @@
+import { type Ora } from 'ora';
+/**
+ * A `dots` spinner on stderr (ora's default stream).
+ *
+ * ora 9 works out how many lines to clear by dividing by
+ * `stream.columns ?? 80`, so a terminal that reports **0** columns — a pty
+ * whose size was never set, as some `docker exec -t`/CI setups give — clears
+ * Infinity lines and hangs the CLI. ora 5 used `columns || 80`. There, fall
+ * back to ora's non-interactive output (a single `- text` line), which is
+ * what a non-TTY gets anyway.
+ *
+ * @private
+ */
+export default function createSpinner(text: string): Ora;

package/dist/types/packages/cli/utils/print-statements.d.ts

@@ -0,0 +1,12 @@
+import type { Knex } from 'knex';
+/**
+ * Print each statement `builder` runs as it runs, with its values. A schema
+ * builder can run several (`create table` and then each `create index`), and
+ * emits `query` once per statement — so the statement comes from the event,
+ * not from `builder.toString()`, which is all of them at once.
+ *
+ * @internal
+ */
+export default function printStatements<T extends {
+    on(event: 'query', fn: (query: Knex.Sql) => void): unknown;
+}>(builder: T, connection: Knex, write?: (text: string) => void): T;

package/dist/types/packages/cli/utils/server-database.d.ts

@@ -0,0 +1,27 @@
+import type { Knex } from 'knex';
+import type { DatabaseEnvironmentConfig } from '../../database';
+/**
+ * `config` pointed at the server instead of the app's database, which may not
+ * exist yet (`db:create`) or is about to go (`db:drop`): PostgreSQL's
+ * `postgres` maintenance database, or no database for MySQL. Every other
+ * setting (host, port, credentials, ssl) is kept.
+ *
+ * @internal
+ */
+export declare function serverConfigFor(config: DatabaseEnvironmentConfig): DatabaseEnvironmentConfig;
+/**
+ * The statement that creates or drops `database`, its name quoted as an
+ * identifier. A PostgreSQL drop is `WITH (FORCE)` (PostgreSQL 13+), so a
+ * server or console still connected doesn't block it; MySQL drops a database
+ * with open connections anyway.
+ *
+ * @internal
+ */
+export declare function statementFor(connection: Knex, action: 'create' | 'drop', driver: string, database: string): Knex.Raw;
+/**
+ * Create or drop the database of `config` on its server, printing the
+ * statement.
+ *
+ * @internal
+ */
+export default function provision(path: string, config: DatabaseEnvironmentConfig, action: 'create' | 'drop'): Promise<void>;

package/dist/types/packages/compiler/interfaces.d.ts

@@ -1 +1 @@
-export type Compiler$manifestWriter = (value: string | Array<string>, resolveName?: (value: string) => string, resolveExport?: (value: string) => string) => Promise<void>;
+export type ManifestWriter = (value: string | Array<string>, resolveName?: (value: string) => string, resolveExport?: (value: string) => string) => Promise<void>;

package/dist/types/packages/config/interfaces.d.ts

@@ -1,6 +1,12 @@
-import type { Logger$config } from '../logger';
-import type { Server$config } from '../server';
+import type { LoggerConfig } from '../logger';
+import type { ServerConfig } from '../server';
+/**
+ * The contents of `config/environments/<environment>.js`. Every member is
+ * merged over the defaults, so an environment file sets only what differs.
+ */
 export type Config = {
-    logging: Logger$config;
-    server: Server$config;
+    /** How and what the app logs; see {@link LoggerConfig}. */
+    logging: LoggerConfig;
+    /** CORS and proxy settings; see {@link ServerConfig}. */
+    server: ServerConfig;
 };

package/dist/types/packages/controller/constants.d.ts

@@ -1,2 +1,7 @@
-import type { Controller$builtIn } from './index';
-export declare const BUILT_IN_ACTIONS: ReadonlyArray<Controller$builtIn>;
+import type { BuiltInAction } from './index';
+export declare const BUILT_IN_ACTIONS: ReadonlyArray<BuiltInAction>;
+/**
+ * Settings a controller takes from its namespace's `ApplicationController`
+ * (and that one from its parent namespace's) unless it sets them itself.
+ */
+export declare const NAMESPACE_SETTINGS: readonly ["rejectUnlistedAttributes", "rejectUnlistedRelationships", "maxIncludeDepth"];

package/dist/types/packages/controller/errors/related-record-not-found-error.d.ts

@@ -1,14 +1,14 @@
 import type { ModelClass } from '../../database';
-import type { Server$ErrorSource } from '../../server';
+import type { ServerErrorSource } from '../../server';
 /**
  * JSON:API 1.0: "A server MUST return 404 Not Found when processing a request
  * that references a related resource that does not exist."
  *
- * @private
+ * @internal
  */
 declare class RelatedRecordNotFoundError extends Error {
-    source: Server$ErrorSource;
+    source: ServerErrorSource;
     constructor({ name, primaryKey }: ModelClass, primaryKeyValue: unknown, path: string);
 }
-declare const _default: new (...args: Array<any>) => RelatedRecordNotFoundError & import("../../server/interfaces").Server$Error;
+declare const _default: new (...args: Array<any>) => RelatedRecordNotFoundError & import("../../server").ServerError;
 export default _default;