npm - lumen-framework - Versions diffs - 3.0.0 - Mend

@@ -0,0 +1,85 @@
+import type Logger from '../logger';
+import type Serializer from '../serializer';
+import type Database from './index';
+import type { Model, Query } from './index';
+import type { Model$Hooks } from './model/interfaces';
+import type { Relationship$opts } from './relationship/interfaces';
+import type { Transaction$ResultProxy } from './transaction/interfaces';
+type Database$pool = number | {
+    min: number;
+    max: number;
+};
+type Database$columnType = 'floating' | 'enu' | 'bool' | 'varchar' | 'bigInteger';
+export type Database$environment = {
+    host?: string;
+    pool?: Database$pool;
+    debug?: boolean;
+    driver: string;
+    socket?: string;
+    database?: string;
+    username?: string;
+    password?: string;
+    port?: number;
+    ssl?: boolean;
+    url?: string;
+};
+export type Database$config = {
+    development: Database$environment;
+    test: Database$environment;
+    production: Database$environment;
+};
+export type Database$opts = {
+    path: string;
+    models: Map<string, ModelClass>;
+    config: Database$config;
+    logger: Logger;
+    checkMigrations?: boolean;
+};
+export type Database$column = {
+    type: Database$columnType;
+    nullable: boolean;
+    maxLength: string;
+    columnName: string;
+    defaultValue: unknown;
+};
+/**
+ * The static-bearing model *class* (`Class<Model>` in the original Flow). The
+ * `Model` base class and its subclasses satisfy this structurally; it is the
+ * type app-facing code (controllers, serializers, the router) refers to when it
+ * holds "a model class".
+ */
+export interface ModelClass<T extends Model = Model> {
+    new (attrs?: Record<string, unknown>, initialize?: boolean): T;
+    prototype: T;
+    name: string;
+    primaryKey: string;
+    tableName: string;
+    modelName: string;
+    resourceName: string;
+    serializer: Serializer<T>;
+    attributes: Record<string, unknown>;
+    attributeNames: Array<string>;
+    relationships: Record<string, Relationship$opts>;
+    relationshipNames: Array<string>;
+    hasOne: Record<string, unknown>;
+    hasMany: Record<string, unknown>;
+    belongsTo: Record<string, unknown>;
+    scopes: Record<string, unknown>;
+    validates: Record<string, unknown>;
+    hooks: Model$Hooks;
+    store: Database;
+    logger: Logger;
+    table(): any;
+    isInstance(value: unknown): boolean;
+    initialize(store: Database, table: () => unknown): Promise<ModelClass>;
+    transaction<R>(fn: (...args: Array<unknown>) => Promise<R>): Promise<R>;
+    columnFor(key: string): Database$column | undefined;
+    columnNameFor(key: string): string | undefined;
+    relationshipFor(key: string): Relationship$opts | undefined;
+    find(primaryKey: unknown): Query<T>;
+    first(): Query<T>;
+    where(conditions: Record<string, unknown>): Query<Array<T>>;
+    select(...columns: Array<string>): Query<Array<T>>;
+    create(attributes?: Record<string, unknown>, trx?: unknown): Promise<Transaction$ResultProxy<T, boolean>>;
+}
+export {};

@@ -0,0 +1,3 @@
+export declare const UNIQUE_CONSTRAINT: RegExp;
+export declare const VALID_DRIVERS: string[];
+export declare const TYPE_ALIASES: Map<string, string>;

@@ -0,0 +1,4 @@
+declare class ConfigMissingError extends Error {
+    constructor(environment: string);
+}
+export default ConfigMissingError;

@@ -0,0 +1,5 @@
+export { default as InvalidDriverError } from './invalid-driver-error';
+export { default as ModelMissingError } from './model-missing-error';
+export { default as MigrationsPendingError } from './migrations-pending-error';
+export { default as UniqueConstraintError } from './unique-constraint-error';
+export { default as ConfigMissingError } from './config-missing-error';

@@ -0,0 +1,7 @@
+/**
+ * @private
+ */
+declare class InvalidDriverError extends Error {
+    constructor(driver: string);
+}
+export default InvalidDriverError;

@@ -0,0 +1,7 @@
+/**
+ * @private
+ */
+declare class MigrationsPendingError extends Error {
+    constructor(migrations?: Array<string>);
+}
+export default MigrationsPendingError;

@@ -0,0 +1,7 @@
+/**
+ * @private
+ */
+declare class ModelMissingError extends Error {
+    constructor(name: string);
+}
+export default ModelMissingError;

@@ -0,0 +1,4 @@
+declare class UniqueConstraintError extends Error {
+}
+declare const _default: new (...args: Array<any>) => UniqueConstraintError & import("../../server/interfaces").Server$Error;
+export default _default;

@@ -0,0 +1,26 @@
+import type { Knex } from 'knex';
+import type Logger from '../logger';
+import type { Database$opts, ModelClass } from './interfaces';
+/**
+ * @private
+ */
+declare class Database {
+    path: string;
+    debug: boolean;
+    logger: Logger;
+    config: Record<string, unknown>;
+    schema: () => Knex.SchemaBuilder;
+    connection: Knex;
+    models: Map<string, ModelClass>;
+    constructor(opts: Database$opts);
+    modelFor(type: string): ModelClass;
+}
+export default Database;
+export { default as Model } from './model';
+export { default as Query } from './query';
+export { default as Migration, generateTimestamp } from './migration';
+export { default as connect } from './utils/connect';
+export { default as typeForColumn } from './utils/type-for-column';
+export { default as createMigrations } from './utils/create-migrations';
+export { default as pendingMigrations } from './utils/pending-migrations';
+export type { Database$opts, Database$config, ModelClass } from './interfaces';

@@ -0,0 +1,6 @@
+import type Database from './index';
+import type { Database$opts } from './index';
+/**
+ * @private
+ */
+export default function initialize<T extends Database>(instance: T, opts: Database$opts): Promise<T>;

@@ -0,0 +1,12 @@
+import type { Migration$Fn } from './interfaces';
+/**
+ * @private
+ */
+declare class Migration<T extends object> {
+    fn: Migration$Fn<T>;
+    constructor(fn: Migration$Fn<T>);
+    run(schema: T): T;
+}
+export default Migration;
+export { default as generateTimestamp } from './utils/generate-timestamp';
+export type { Migration$Fn } from './interfaces';

	@@ -0,0 +1,2 @@
1	+ export declare function padding(char: string, amount: number): Generator<string, void, void>;
2	+ export default function generateTimestamp(): string;

lumen-framework 3.0.0