lumen-framework 3.1.1 → 4.0.0

package/dist/types/packages/database/model/initialize-class.d.ts

@@ -1,8 +1,14 @@
 import type Database from '../index';
 import type { ModelClass } from '../interfaces';
 /**
- * @private
+ * The foreign key of a `hasOne` or non-through `hasMany` that does not
+ * declare one: its inverse `belongsTo`'s, which may declare it, else
+ * `<inverse>_id`. Models initialize concurrently, so `related.belongsTo` is
+ * either still its declaration or already initialized; both carry a declared
+ * `foreignKey`, and the default is the same.
  */
+export declare function inverseForeignKey(related: ModelClass, inverse: string): string;
+/** @internal */
 export default function initializeClass<T extends ModelClass>({ store, table, model }: {
     store: Database;
     table: T['table'];

package/dist/types/packages/database/model/interfaces.d.ts

@@ -1,14 +1,32 @@
 import type Model from './index';
-export type Model$Hook = (instance: Model, trx: unknown) => Promise<unknown>;
-export interface Model$Hooks {
-    readonly afterCreate?: Model$Hook;
-    readonly afterDestroy?: Model$Hook;
-    readonly afterSave?: Model$Hook;
-    readonly afterUpdate?: Model$Hook;
-    readonly afterValidation?: Model$Hook;
-    readonly beforeCreate?: Model$Hook;
-    readonly beforeDestroy?: Model$Hook;
-    readonly beforeSave?: Model$Hook;
-    readonly beforeUpdate?: Model$Hook;
-    readonly beforeValidation?: Model$Hook;
+/**
+ * A model lifecycle hook: called with the record and the write's
+ * transaction. See {@link Model.hooks}.
+ */
+export type ModelHook = (instance: Model, trx: unknown) => Promise<unknown>;
+/**
+ * The hooks a model declares in {@link Model.hooks}, by the point in a
+ * record's life they run at.
+ */
+export interface ModelHooks {
+    /** After a record is inserted, in its transaction. */
+    readonly afterCreate?: ModelHook;
+    /** After a record is deleted, in its transaction. */
+    readonly afterDestroy?: ModelHook;
+    /** After a record is inserted or updated; last. */
+    readonly afterSave?: ModelHook;
+    /** After a record is updated, in its transaction. */
+    readonly afterUpdate?: ModelHook;
+    /** After the record's validations pass. */
+    readonly afterValidation?: ModelHook;
+    /** Before a record is inserted, after validation. */
+    readonly beforeCreate?: ModelHook;
+    /** Before a record is deleted. */
+    readonly beforeDestroy?: ModelHook;
+    /** Before a record is inserted or updated; last before the write. */
+    readonly beforeSave?: ModelHook;
+    /** Before a record is updated, after validation. */
+    readonly beforeUpdate?: ModelHook;
+    /** Before the record's validations run, on create and update. */
+    readonly beforeValidation?: ModelHook;
 }

package/dist/types/packages/database/model/utils/attribute.d.ts

@@ -0,0 +1,14 @@
+import type Model from '../index';
+/**
+ * Read an attribute (or relationship) of `record` by name.
+ *
+ * @internal
+ */
+export declare function readAttribute(record: Model, key: string): unknown;
+/**
+ * Write an attribute (or relationship) of `record` by name. Unlike
+ * `Reflect.set`, a failed write throws rather than returning `false`.
+ *
+ * @internal
+ */
+export declare function writeAttribute(record: Model, key: string, value: unknown): void;

package/dist/types/packages/database/model/utils/get-columns.d.ts

@@ -1,5 +1,3 @@
 import type Model from '../index';
-/**
- * @private
- */
+/** @internal */
 export default function getColumns(record: Model, only?: Array<string>): Record<string, unknown>;

package/dist/types/packages/database/model/utils/persistence.d.ts

@@ -1,18 +1,9 @@
-import type Logger from '../../../logger';
 import type Model from '../index';
-/**
- * @private
- */
+/** @internal */
 export declare function create(record: Model, trx: unknown): Array<any>;
-/**
- * @private
- */
+/** @internal */
 export declare function update(record: Model, trx: unknown): Array<any>;
-/**
- * @private
- */
+/** @internal */
 export declare function destroy(record: Model, trx: unknown): Array<any>;
-/**
- * @private
- */
-export declare function createRunner(logger: Logger, statements: Array<any>): (query: Array<any>) => Promise<Array<any>>;
+/** @internal */
+export declare function createRunner({ logger, store }: Pick<typeof Model, 'logger' | 'store'>, statements: Array<any>): (query: Array<any>) => Promise<Array<any>>;

package/dist/types/packages/database/model/utils/process-write-error.d.ts

@@ -1,12 +1,12 @@
 /**
  * Map a database write error to the server error it should surface as.
  *
- * @private
+ * @internal
  */
 export default function processWriteError(err: unknown): unknown;
 /**
  * `.catch()` handler for a write: rethrows the mapped error.
  *
- * @private
+ * @internal
  */
 export declare function rethrowWriteError(err: unknown): never;

package/dist/types/packages/database/model/utils/run-hooks.d.ts

@@ -1,6 +1,10 @@
 import type Model from '../index';
-import type { Model$Hook } from '../interfaces';
+import type { ModelHook } from '../interfaces';
 /**
- * @private
+ * Run `hooks` in order. Each receives the record bound to the write's
+ * transaction — so its relationship reads, `update`, `save` and `reload` join
+ * it — and the transaction itself, for queries on other models.
+ *
+ * @internal
  */
-export default function runHooks(record: Model, trx: unknown, ...hooks: Array<Model$Hook | undefined>): Promise<unknown>;
+export default function runHooks(target: Model, trx: unknown, ...hooks: Array<ModelHook | undefined>): Promise<unknown>;

package/dist/types/packages/database/model/utils/validate.d.ts

@@ -1,5 +1,8 @@
 import type { Model } from '../../index';
 /**
- * @private
+ * Run the model's validators over its dirty attributes. Every attribute that
+ * fails is reported (one 422 error object each), not just the first.
+ *
+ * @internal
  */
 export default function validate(instance: Model): true;

package/dist/types/packages/database/query/errors/record-not-found-error.d.ts

@@ -2,5 +2,5 @@ import type { ModelClass } from '../../interfaces';
 declare class RecordNotFoundError extends Error {
     constructor({ name, primaryKey }: ModelClass, primaryKeyValue: unknown);
 }
-declare const _default: new (...args: Array<any>) => RecordNotFoundError & import("../../../server/interfaces").Server$Error;
+declare const _default: new (...args: Array<any>) => RecordNotFoundError & import("../../../server").ServerError;
 export default _default;

package/dist/types/packages/database/query/index.d.ts

@@ -1,38 +1,214 @@
 import type { ModelClass } from '../interfaces';
 /**
- * @class Query
- * @extends Promise
- * @private
+ * The snapshots that narrow which rows match — the only ones `count()` keeps.
+ * Every condition the query builder can push belongs here: dropping one makes
+ * the count (and so the index action's page links) disagree with the rows.
+ *
+ * @internal
+ */
+declare const CONDITIONS: Set<string>;
+/**
+ * A lazily built database query. `Model.all()`, `Model.where()`,
+ * `Model.find()` and the other static query methods start one; chain more
+ * methods, and the model's scopes, onto it, and `await` it to run it:
+ *
+ * ```javascript
+ * const posts = await Post.where({ isPublic: true })
+ *   .order('createdAt', 'DESC')
+ *   .include('user')
+ *   .page(2);
+ * ```
+ *
+ * A query resolves with an array of records, or with one record after
+ * {@link Query.find}, {@link Query.first} or {@link Query.last}, or with a
+ * number after {@link Query.count}. A controller action may return a query
+ * without awaiting it; Lumen runs it and serializes the result.
  */
 declare class Query<T = any> extends Promise<T> {
+    /** @internal */
     model: ModelClass;
+    /** @internal */
     isFind: boolean;
+    /** @internal */
     snapshots: Array<Array<any>>;
+    /** @internal */
     collection: boolean;
+    /** @internal */
     shouldCount: boolean;
+    /** @internal */
     relationships: Record<string, any>;
+    /** @internal */
+    trx: unknown;
     constructor(model: ModelClass);
     static get [Symbol.species](): PromiseConstructor;
+    /**
+     * Run the query — and the queries that load its included relationships —
+     * in the transaction `trx`, so it sees the rows the transaction has written
+     * and does not wait for another connection while the transaction holds
+     * one. Model hooks receive the write's transaction for this:
+     *
+     * ```javascript
+     * static hooks = {
+     *   async afterCreate(comment, trx) {
+     *     const post = await Post.transacting(trx).find(comment.postId);
+     *     // …
+     *   }
+     * };
+     * ```
+     *
+     * `Model.transacting(trx)` starts a query that is already bound, as above;
+     * this method binds one built another way.
+     */
+    transacting(trx: unknown): this;
+    /**
+     * Every record: adds no condition. `Model.all()` reads better than a bare
+     * query.
+     */
     all(): this;
+    /**
+     * The records that do *not* match `conditions`; the opposite of
+     * {@link Query.where}, with the same conditions.
+     *
+     * ```javascript
+     * await User.not({ name: 'Bob' });
+     * await User.not({ deletedAt: null }); // deleted_at IS NOT NULL
+     * ```
+     */
     not(conditions?: Record<string, any>): this;
+    /**
+     * The record with primary key `primaryKey`. The query resolves with the
+     * record, or rejects with a `RecordNotFoundError` — a `404` through the API —
+     * if there is none.
+     *
+     * ```javascript
+     * const post = await Post.find(1);
+     * ```
+     */
     find(primaryKey: any): this;
+    /**
+     * Page `num` of the records, counting from 1. The page size is the query's
+     * {@link Query.limit}, or 25.
+     *
+     * ```javascript
+     * await Post.order('createdAt', 'DESC').limit(10).page(2); // records 11–20
+     * ```
+     */
     page(num?: number): this;
+    /**
+     * At most `amount` records.
+     */
     limit(amount?: number): this;
+    /**
+     * Sort by the attribute `attr`, `'ASC'` (the default) or `'DESC'`. Ties are
+     * broken by the primary key, so pages are stable. A later `order` replaces an
+     * earlier one; an attribute the model doesn't have is ignored.
+     *
+     * ```javascript
+     * await Post.order('createdAt', 'DESC');
+     * ```
+     */
     order(attr: string, direction?: string): this;
+    /**
+     * The records matching every condition in `conditions`, an object of
+     * attribute names (camelCase, as on records) and values:
+     *
+     * ```javascript
+     * await Post.where({ userId: 1, isPublic: true });
+     * await Post.where({ id: [1, 2, 3] });   // any of: id IN (1, 2, 3)
+     * await Post.where({ publishedAt: null }); // published_at IS NULL
+     * ```
+     *
+     * Names that aren't attributes of the model are ignored. Calls chain as
+     * `AND`.
+     *
+     * @param not - Used by {@link Query.not}.
+     */
     where(conditions?: Record<string, any>, not?: boolean): this;
+    /**
+     * The records whose attributes lie within ranges, inclusive:
+     *
+     * ```javascript
+     * await Post.whereBetween({ createdAt: [lastWeek, now] });
+     * ```
+     *
+     * @param not - `true` for the records *outside* the ranges.
+     */
     whereBetween(conditions: Record<string, any>, not?: boolean): this;
+    /**
+     * The records matching a raw SQL condition, with `?` placeholders for
+     * `bindings`. Columns are snake_case here, as in the database:
+     *
+     * ```javascript
+     * await Post.whereRaw('lower(title) LIKE ?', ['%lumen%']);
+     * ```
+     *
+     * Never build `query` from user input; pass values as `bindings`.
+     */
     whereRaw(query: string, bindings?: Array<any>): this;
+    /**
+     * Only the first record — by primary key, or by the query's
+     * {@link Query.order} — instead of an array. Resolves with `undefined` when
+     * nothing matches.
+     */
     first(): this;
+    /**
+     * Only the last record — by primary key, or by the query's
+     * {@link Query.order} — instead of an array. Resolves with `undefined` when
+     * nothing matches.
+     */
     last(): this;
+    /**
+     * The number of matching records, instead of the records. Only the query's
+     * conditions count; `limit`, `page`, `order` and `include` are ignored.
+     *
+     * ```javascript
+     * const total = await Post.where({ isPublic: true }).count();
+     * ```
+     */
     count(): Query<number>;
+    /**
+     * Skip the first `amount` records.
+     */
     offset(amount: number): this;
+    /**
+     * Load only these attributes. Include the primary key when you will use
+     * the records for more than reading these values.
+     *
+     * ```javascript
+     * await User.select('id', 'name');
+     * ```
+     */
     select(...attrs: Array<string>): this;
+    /**
+     * Only unique combinations of these attributes.
+     */
     distinct(...attrs: Array<string>): this;
+    /**
+     * Load these relationships with the records, so reading them doesn't cost
+     * a query per record:
+     *
+     * ```javascript
+     * const posts = await Post.where({ isPublic: true }).include('user', 'tags');
+     * ```
+     *
+     * Pass an object to load only some attributes of each:
+     * `include({ user: ['name'] })`.
+     */
     include(...relationships: Array<Record<string, any> | string>): this;
+    /**
+     * Remove scopes from the query — by name, or every scope when called
+     * without arguments. `'order'` removes the sort order.
+     *
+     * ```javascript
+     * await Post.isPublic().unscope('isPublic');
+     * ```
+     */
     unscope(...scopes: Array<string>): this;
     then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((error: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onRejected?: ((error: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    /** @internal */
     static from(src: any): Query<unknown>;
 }
 export default Query;
 export { RecordNotFoundError } from './errors';
+export { CONDITIONS };

package/dist/types/packages/database/query/runner/index.d.ts

@@ -1,7 +1,5 @@
 import type Query from '../index';
-/**
- * @private
- */
+/** @internal */
 export declare function createRunner(target: Query<unknown>, opts: {
     resolve?: (value: any) => void;
     reject?: (error: Error) => void;

package/dist/types/packages/database/query/runner/utils/build-results.d.ts

@@ -1,10 +1,9 @@
 import type Model from '../../../model';
 import type { ModelClass } from '../../../interfaces';
-/**
- * @private
- */
-export default function buildResults<T extends Model>({ model, records, relationships }: {
+/** @internal */
+export default function buildResults<T extends Model>({ model, records, relationships, trx }: {
     model: ModelClass<T>;
     records: Promise<Array<Record<string, any>>>;
     relationships: Record<string, any>;
+    trx?: unknown;
 }): Promise<Array<T>>;

package/dist/types/packages/database/query/utils/format-select.d.ts

@@ -1,5 +1,3 @@
 import type { ModelClass } from '../../interfaces';
-/**
- * @private
- */
+/** @internal */
 export default function formatSelect(model: ModelClass, attrs?: Array<string>, prefix?: string): string[];

package/dist/types/packages/database/relationship/index.d.ts

@@ -1,11 +1,12 @@
 import type Model from '../model';
-/**
- * @private
- */
+/** @internal */
 export declare function set(owner: Model, key: string, value?: Array<Model> | Model | null): void;
 /**
- * @private
+ * The value of `owner`'s relationship `key`: the loaded or assigned one, or
+ * else read from the database — in `trx` when given.
+ *
+ * @internal
  */
-export declare function get(owner: Model, key: string): Promise<Array<Model> | Model | null>;
+export declare function get(owner: Model, key: string, trx?: unknown): Promise<Array<Model> | Model | null>;
 export { default as updateRelationship } from './utils/update-relationship';
-export type { Relationship$opts } from './interfaces';
+export type { RelationshipOptions } from './interfaces';

package/dist/types/packages/database/relationship/interfaces.d.ts

@@ -1,12 +1,25 @@
 import type { Model } from '../index';
 import type { ModelClass } from '../interfaces';
-type Relationship$ref = Model | Array<Model>;
-export type Relationship$refs = WeakMap<Model, Map<string, Relationship$ref>>;
-export type Relationship$opts = {
+type RelationshipRef = Model | Array<Model>;
+export type RelationshipRefs = WeakMap<Model, Map<string, RelationshipRef>>;
+/**
+ * A relationship as Lumen resolves it when the app boots, from a model's
+ * {@link Model.hasOne}, {@link Model.hasMany} or {@link Model.belongsTo}
+ * declaration.
+ */
+export type RelationshipOptions = {
+    /** Which kind of relationship it is. */
     type: 'hasOne' | 'hasMany' | 'belongsTo';
+    /** The related model. */
     model: ModelClass;
+    /** The name of the relationship on the related model that points back. */
     inverse: string;
+    /** The join model of a many-to-many relationship. */
     through?: ModelClass;
+    /**
+     * The foreign key column: the declared `foreignKey`, or one derived from
+     * the relationship's names.
+     */
     foreignKey: string;
 };
 export {};

package/dist/types/packages/database/relationship/utils/getters.d.ts

@@ -1,14 +1,8 @@
 import type Model from '../../model';
-import type { Relationship$opts } from '../index';
-/**
- * @private
- */
-export declare function getHasOne(owner: Model, { model, foreignKey }: Relationship$opts): import("../..").Query<Model>;
-/**
- * @private
- */
-export declare function getHasMany(owner: Model, opts: Relationship$opts): Promise<Model[]>;
-/**
- * @private
- */
-export declare function getBelongsTo(owner: Model, { model, foreignKey }: Relationship$opts): import("../..").Query<Model> | Promise<null>;
+import type { RelationshipOptions } from '../index';
+/** @internal */
+export declare function getHasOne(owner: Model, { model, foreignKey }: RelationshipOptions, trx?: unknown): import("../..").Query<Model>;
+/** @internal */
+export declare function getHasMany(owner: Model, opts: RelationshipOptions, trx?: unknown): Promise<Model[]>;
+/** @internal */
+export declare function getBelongsTo(owner: Model, { model, foreignKey }: RelationshipOptions, trx?: unknown): import("../..").Query<Model> | Promise<null>;

package/dist/types/packages/database/relationship/utils/inverse-setters.d.ts

@@ -1,15 +1,11 @@
 import type Model from '../../model';
 import type { ModelClass } from '../../interfaces';
-import type { Relationship$opts } from '../index';
-/**
- * @private
- */
-export declare function setHasManyInverse(owner: Model, value: Array<Model>, { inverse, foreignKey, inverseModel }: Relationship$opts & {
+import type { RelationshipOptions } from '../index';
+/** @internal */
+export declare function setHasManyInverse(owner: Model, value: Array<Model>, { inverse, foreignKey, inverseModel }: RelationshipOptions & {
     inverseModel: ModelClass;
 }): void;
-/**
- * @private
- */
-export declare function setHasOneInverse(owner: Model, value: Model | null | undefined, { inverse, foreignKey, inverseModel }: Relationship$opts & {
+/** @internal */
+export declare function setHasOneInverse(owner: Model, value: Model | null | undefined, { inverse, foreignKey, inverseModel }: RelationshipOptions & {
     inverseModel: ModelClass;
 }): void;

package/dist/types/packages/database/relationship/utils/setters.d.ts

@@ -1,14 +1,8 @@
 import type Model from '../../model';
-import type { Relationship$opts } from '../index';
-/**
- * @private
- */
-export declare function setHasMany(owner: Model, key: string, value: Array<Model>, { type, model, inverse, foreignKey }: Relationship$opts): void;
-/**
- * @private
- */
-export declare function setHasOne(owner: Model, key: string, value: Model | null | undefined, { type, model, inverse, foreignKey }: Relationship$opts): void;
-/**
- * @private
- */
-export declare function setBelongsTo(owner: Model, key: string, value: Model | null | undefined, { type, model, inverse, foreignKey }: Relationship$opts): void;
+import type { RelationshipOptions } from '../index';
+/** @internal */
+export declare function setHasMany(owner: Model, key: string, value: Array<Model>, { type, model, inverse, foreignKey }: RelationshipOptions): void;
+/** @internal */
+export declare function setHasOne(owner: Model, key: string, value: Model | null | undefined, { type, model, inverse, foreignKey }: RelationshipOptions): void;
+/** @internal */
+export declare function setBelongsTo(owner: Model, key: string, value: Model | null | undefined, { type, model, inverse, foreignKey }: RelationshipOptions): void;

package/dist/types/packages/database/relationship/utils/unassociate.d.ts

@@ -1,5 +1,3 @@
 import type Model from '../../model';
-/**
- * @private
- */
+/** @internal */
 export default function unassociate<T extends Model>(value: Array<T>, foreignKey: string): Array<T>;

package/dist/types/packages/database/relationship/utils/update-relationship.d.ts

@@ -1,5 +1,9 @@
 import type Model from '../../model';
 /**
- * @private
+ * The statements that persist the relationship `name` of `record`, if it
+ * changed. A has-many-through relationship is written to its join table
+ * before this resolves, and contributes no statements.
+ *
+ * @internal
  */
-export default function updateRelationship(record: Model, name: string, trx: unknown): Array<unknown>;
+export default function updateRelationship(record: Model, name: string, trx: unknown): Promise<Array<unknown>>;

package/dist/types/packages/database/transaction/index.d.ts

@@ -1,16 +1,15 @@
 import type { Model } from '../index';
 import type { ModelClass } from '../interfaces';
-import type { Transaction$ResultProxy } from './interfaces';
+import type { TransactionResult } from './interfaces';
 /**
- * @private
+ * `target` with `create` writing in `trx`, and every static that starts a
+ * query (`find`, `where`, `first`, a scope, …) returning one that runs in it.
+ *
+ * @internal
  */
 export declare function createStaticTransactionProxy<T extends ModelClass>(target: T, trx: unknown): T;
-/**
- * @private
- */
+/** @internal */
 export declare function createInstanceTransactionProxy<T extends Model>(target: T, trx: unknown): T;
-/**
- * @private
- */
-export declare function createTransactionResultProxy<T extends Model, U extends boolean>(record: T, didPersist: U): Transaction$ResultProxy<T, U>;
-export type { Transaction$ResultProxy } from './interfaces';
+/** @internal */
+export declare function createTransactionResultProxy<T extends Model, U extends boolean>(record: T, didPersist: U): TransactionResult<T, U>;
+export type { TransactionResult } from './interfaces';

package/dist/types/packages/database/transaction/interfaces.d.ts

@@ -1,5 +1,11 @@
 import type { Model } from '../index';
-export type Transaction$ResultProxy<T extends Model, U extends boolean> = T & {
+/**
+ * What a write (`create`, `update`, `save`, `destroy`) resolves with: the
+ * record, with two extra members.
+ */
+export type TransactionResult<T extends Model, U extends boolean> = T & {
+    /** Whether the write changed anything in the database. */
     didPersist: U;
+    /** The record itself, without these members. */
     unwrap(): T;
 };

package/dist/types/packages/database/utils/connect.d.ts

@@ -1,6 +1,19 @@
 import type { Knex } from 'knex';
-import type { Database$environment } from '../interfaces';
+import type { DatabaseEnvironmentConfig } from '../interfaces';
 /**
- * @private
+ * The knex `connection` for an environment's database config.
+ *
+ * A URL — `DATABASE_URL`, else the environment's `url` — gives the host,
+ * credentials and database, and replaces those settings. `ssl` from the
+ * config still applies on top of it (for `pg` and `mysql2`, which take the
+ * URL as `connectionString` / `uri` next to their other options), so an app
+ * on a platform that sets `DATABASE_URL` can configure TLS in
+ * `config/database.js`. A TLS setting written in the URL itself
+ * (`?sslmode=…` for `pg`, `?ssl=…` for `mysql2`) takes precedence: the
+ * drivers apply what they parse from the URL last.
+ *
+ * @internal
  */
-export default function connect(path: string, config: Database$environment): Knex;
+export declare function connectionFor(path: string, config: DatabaseEnvironmentConfig, databaseUrl?: string | undefined): string | Record<string, unknown>;
+/** @internal */
+export default function connect(path: string, config: DatabaseEnvironmentConfig): Knex;

package/dist/types/packages/database/utils/create-migrations.d.ts

@@ -1,5 +1,3 @@
 import type Database from '../index';
-/**
- * @private
- */
+/** @internal */
 export default function createMigrations(schema: Database['schema']): Promise<boolean>;

package/dist/types/packages/database/utils/normalize-model-name.d.ts

@@ -1,5 +1,3 @@
-/**
- * @private
- */
+/** @internal */
 declare const _default: (input: unknown) => string;
 export default _default;

package/dist/types/packages/database/utils/pending-migrations.d.ts

@@ -1,4 +1,2 @@
-/**
- * @private
- */
+/** @internal */
 export default function pendingMigrations(appPath: string, table: () => any): Promise<Array<string>>;

package/dist/types/packages/database/utils/primary-key-type.d.ts

@@ -0,0 +1,10 @@
+import type { ModelClass } from '../interfaces';
+/**
+ * The type of `model`'s primary key column: `'number'` for an auto-increment
+ * id, `'string'` for e.g. a uuid or `varchar` (PostgreSQL reports the latter
+ * as `character varying`, which `typeForColumn` does not know). `'number'`
+ * when the column is unknown.
+ *
+ * @internal
+ */
+export default function primaryKeyType(model: ModelClass): string;