@mikro-orm/knex 6.0.0-dev.2 → 6.0.0-dev.200

package/dist/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2018 Martin Adámek
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/SqlEntityRepository.d.ts

@@ -1,23 +0,0 @@
-import type { Knex } from 'knex';
-import type { EntityName } from '@mikro-orm/core';
-import { EntityRepository } from '@mikro-orm/core';
-import type { SqlEntityManager } from './SqlEntityManager';
-import type { QueryBuilder } from './query';
-export declare class SqlEntityRepository<T> extends EntityRepository<T> {
-    protected readonly _em: SqlEntityManager;
-    protected readonly entityName: EntityName<T>;
-    constructor(_em: SqlEntityManager, entityName: EntityName<T>);
-    /**
-     * Creates a QueryBuilder instance
-     */
-    createQueryBuilder(alias?: string): QueryBuilder<T>;
-    /**
-     * Shortcut for `createQueryBuilder()`
-     */
-    qb(alias?: string): QueryBuilder<T>;
-    /**
-     * Returns configured knex instance.
-     */
-    getKnex(type?: 'read' | 'write'): Knex;
-    protected get em(): SqlEntityManager;
-}

package/dist/index.mjs

@@ -1,26 +0,0 @@
-import mod from "./index.js";
-
-export default mod;
-export const AbstractSqlConnection = mod.AbstractSqlConnection;
-export const AbstractSqlDriver = mod.AbstractSqlDriver;
-export const AbstractSqlPlatform = mod.AbstractSqlPlatform;
-export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
-export const CriteriaNode = mod.CriteriaNode;
-export const CriteriaNodeFactory = mod.CriteriaNodeFactory;
-export const DatabaseSchema = mod.DatabaseSchema;
-export const DatabaseTable = mod.DatabaseTable;
-export const EntityManager = mod.EntityManager;
-export const EntityRepository = mod.EntityRepository;
-export const Knex = mod.Knex;
-export const MonkeyPatchable = mod.MonkeyPatchable;
-export const ObjectCriteriaNode = mod.ObjectCriteriaNode;
-export const QueryBuilder = mod.QueryBuilder;
-export const QueryBuilderHelper = mod.QueryBuilderHelper;
-export const QueryType = mod.QueryType;
-export const ScalarCriteriaNode = mod.ScalarCriteriaNode;
-export const SchemaComparator = mod.SchemaComparator;
-export const SchemaGenerator = mod.SchemaGenerator;
-export const SchemaHelper = mod.SchemaHelper;
-export const SqlEntityManager = mod.SqlEntityManager;
-export const SqlEntityRepository = mod.SqlEntityRepository;
-export const knex = mod.knex;

package/dist/package.json

@@ -1,99 +0,0 @@
-{
-  "name": "@mikro-orm/knex",
-  "version": "5.0.0",
-  "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": "./index.mjs",
-      "require": "./index.js"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
-  "keywords": [
-    "orm",
-    "mongo",
-    "mongodb",
-    "mysql",
-    "mariadb",
-    "postgresql",
-    "sqlite",
-    "sqlite3",
-    "ts",
-    "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
-  ],
-  "author": "Martin Adámek",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/mikro-orm/mikro-orm/issues"
-  },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 14.0.0"
-  },
-  "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
-    "postbuild": "yarn gen-esm-wrapper index.js index.mjs",
-    "clean": "rimraf ./dist",
-    "compile": "tsc -p tsconfig.build.json",
-    "copy": "ts-node -T ../../scripts/copy.ts"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "fs-extra": "10.0.0",
-    "knex": "1.0.1",
-    "sqlstring": "2.3.2"
-  },
-  "devDependencies": {
-    "@mikro-orm/core": "^5.0.0"
-  },
-  "peerDependencies": {
-    "@mikro-orm/core": "^5.0.0",
-    "@mikro-orm/entity-generator": "^5.0.0",
-    "@mikro-orm/migrations": "^5.0.0",
-    "@vscode/sqlite3": "^5.0.0",
-    "mssql": "^7.0.0",
-    "mysql": "^2.18.1",
-    "mysql2": "^2.1.0",
-    "pg": "^8.0.3"
-  },
-  "peerDependenciesMeta": {
-    "@mikro-orm/entity-generator": {
-      "optional": true
-    },
-    "@mikro-orm/migrations": {
-      "optional": true
-    },
-    "@vscode/sqlite3": {
-      "optional": true
-    },
-    "mssql": {
-      "optional": true
-    },
-    "mysql": {
-      "optional": true
-    },
-    "mysql2": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    }
-  }
-}

package/dist/query/ArrayCriteriaNode.d.ts

@@ -1,9 +0,0 @@
-import { CriteriaNode } from './CriteriaNode';
-import type { IQueryBuilder } from '../typings';
-/**
- * @internal
- */
-export declare class ArrayCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): any;
-}

package/dist/query/CriteriaNodeFactory.d.ts

@@ -1,12 +0,0 @@
-import type { Dictionary, EntityMetadata, MetadataStorage } from '@mikro-orm/core';
-import type { ICriteriaNode } from '../typings';
-/**
- * @internal
- */
-export declare class CriteriaNodeFactory {
-    static createNode(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createScalarNode(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createArrayNode(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createObjectNode(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode, key?: string): ICriteriaNode;
-    static createObjectItemNode(metadata: MetadataStorage, entityName: string, node: ICriteriaNode, payload: Dictionary, item: string, meta?: EntityMetadata): ICriteriaNode;
-}

package/dist/query/ObjectCriteriaNode.d.ts

@@ -1,14 +0,0 @@
-import { CriteriaNode } from './CriteriaNode';
-import type { IQueryBuilder } from '../typings';
-/**
- * @internal
- */
-export declare class ObjectCriteriaNode extends CriteriaNode {
-    process<T>(qb: IQueryBuilder<T>, alias?: string): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
-    shouldInline(payload: any): boolean;
-    private inlineChildPayload;
-    private shouldAutoJoin;
-    private autoJoin;
-    private isPrefixed;
-}

package/dist/query/QueryBuilder.d.ts

@@ -1,211 +0,0 @@
-import type { Knex } from 'knex';
-import type { AnyEntity, Dictionary, EntityData, EntityProperty, RequiredEntityData, GroupOperator, MetadataStorage, PopulateOptions, QBFilterQuery, QueryOrderMap, QueryResult, FlushMode } from '@mikro-orm/core';
-import { LockMode, QueryFlag } from '@mikro-orm/core';
-import { QueryType } from './enums';
-import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-import type { SqlEntityManager } from '../SqlEntityManager';
-import type { Field } from '../typings';
-/**
- * SQL query builder with fluent interface.
- *
- * ```ts
- * const qb = orm.em.createQueryBuilder(Publisher);
- * qb.select('*')
- *   .where({
- *     name: 'test 123',
- *     type: PublisherType.GLOBAL,
- *   })
- *   .orderBy({
- *     name: QueryOrder.DESC,
- *     type: QueryOrder.ASC,
- *   })
- *   .limit(2, 1);
- *
- * const publisher = await qb.getSingleResult();
- * ```
- */
-export declare class QueryBuilder<T extends AnyEntity<T> = AnyEntity> {
-    private readonly entityName;
-    private readonly metadata;
-    private readonly driver;
-    private readonly context?;
-    private connectionType?;
-    private readonly em?;
-    readonly alias: string;
-    /** @internal */
-    type: QueryType;
-    /** @internal */
-    _fields?: Field<T>[];
-    /** @internal */
-    _populate: PopulateOptions<T>[];
-    /** @internal */
-    _populateMap: Dictionary<string>;
-    private aliasCounter;
-    private flags;
-    private finalized;
-    private _joins;
-    private _aliasMap;
-    private _schema?;
-    private _cond;
-    private _data;
-    private _orderBy;
-    private _groupBy;
-    private _having;
-    private _onConflict?;
-    private _limit?;
-    private _offset?;
-    private _joinedProps;
-    private _cache?;
-    private _indexHint?;
-    private flushMode?;
-    private lockMode?;
-    private lockTables?;
-    private subQueries;
-    private innerPromise?;
-    private readonly platform;
-    private readonly knex;
-    private readonly helper;
-    /**
-     * @internal
-     */
-    constructor(entityName: string, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: "write" | "read" | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection>> | undefined);
-    select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
-    addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
-    insert(data: RequiredEntityData<T> | RequiredEntityData<T>[]): InsertQueryBuilder<T>;
-    update(data: EntityData<T>): UpdateQueryBuilder<T>;
-    delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
-    truncate(): TruncateQueryBuilder<T>;
-    count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
-    join(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
-    leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
-    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery, type?: 'leftJoin' | 'innerJoin' | 'pivotJoin', path?: string): this;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    protected getFieldsForJoinedLoad<U extends AnyEntity<U>>(prop: EntityProperty<U>, alias: string): Field<U>[];
-    withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
-    where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
-    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
-    andWhere(cond: QBFilterQuery<T>): this;
-    andWhere(cond: string, params?: any[]): this;
-    orWhere(cond: QBFilterQuery<T>): this;
-    orWhere(cond: string, params?: any[]): this;
-    orderBy(orderBy: QueryOrderMap<unknown> | QueryOrderMap<unknown>[]): this;
-    groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): this;
-    having(cond?: QBFilterQuery | string, params?: any[]): this;
-    onConflict(fields?: string | string[]): this;
-    ignore(): this;
-    merge(data?: EntityData<T> | Field<T>[]): this;
-    /**
-     * @internal
-     */
-    populate(populate: PopulateOptions<T>[]): this;
-    /**
-     * @internal
-     */
-    ref(field: string): Knex.Ref<string, {
-        [x: string]: string;
-    }>;
-    raw<R = Knex.Raw>(sql: string, bindings?: Knex.RawBinding[] | Knex.ValueDict): R;
-    limit(limit?: number, offset?: number): this;
-    offset(offset?: number): this;
-    withSchema(schema?: string): this;
-    setLockMode(mode?: LockMode, tables?: string[]): this;
-    setFlushMode(flushMode?: FlushMode): this;
-    setFlag(flag: QueryFlag): this;
-    unsetFlag(flag: QueryFlag): this;
-    cache(config?: boolean | number | [string, number]): this;
-    /**
-     * Adds index hint to the FROM clause.
-     */
-    indexHint(sql: string): this;
-    getKnexQuery(): Knex.QueryBuilder;
-    /**
-     * Returns the query with parameters as wildcards.
-     */
-    getQuery(): string;
-    /**
-     * Returns the list of all parameters for this query.
-     */
-    getParams(): readonly Knex.Value[];
-    /**
-     * Returns raw interpolated query string with all the parameters inlined.
-     */
-    getFormattedQuery(): string;
-    getAliasForJoinPath(path?: string): string | undefined;
-    getNextAlias(entityName?: string): string;
-    /**
-     * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
-     * Use `method` to specify what kind of result you want to get (array/single/meta).
-     */
-    execute<U = any>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    /**
-     * Alias for `qb.getResultList()`
-     */
-    getResult(): Promise<T[]>;
-    /**
-     * Executes the query, returning array of results
-     */
-    getResultList(): Promise<T[]>;
-    /**
-     * Executes the query, returning the first result or null
-     */
-    getSingleResult(): Promise<T | null>;
-    /**
-     * Executes count query (without offset and limit), returning total count of results
-     */
-    getCount(field?: string | string[], distinct?: boolean): Promise<number>;
-    /**
-     * Provides promise-like interface so we can await the QB instance.
-     */
-    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[] | number | QueryResult<T>>;
-    private getInnerPromise;
-    /**
-     * Returns knex instance with sub-query aliased with given alias.
-     * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
-     */
-    as(alias: string): Knex.QueryBuilder;
-    clone(): QueryBuilder<T>;
-    getKnex(): Knex.QueryBuilder;
-    private joinReference;
-    private prepareFields;
-    private init;
-    private getQueryBase;
-    private finalize;
-    private wrapPaginateSubQuery;
-    private wrapModifySubQuery;
-    private autoJoinPivotTable;
-}
-export interface RunQueryBuilder<T> extends Omit<QueryBuilder<T>, 'getResult' | 'getSingleResult' | 'getResultList' | 'where'> {
-    where(cond: QBFilterQuery<T> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
-    execute<U = QueryResult<T>>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    then<TResult1 = QueryResult<T>, TResult2 = never>(onfulfilled?: ((value: QueryResult<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<T>>;
-}
-export interface SelectQueryBuilder<T> extends QueryBuilder<T> {
-    execute<U = T[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    execute<U = T[]>(method: 'all', mapResults?: boolean): Promise<U>;
-    execute<U = T>(method: 'get', mapResults?: boolean): Promise<U>;
-    execute<U = QueryResult<T>>(method: 'run', mapResults?: boolean): Promise<U>;
-    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[]>;
-}
-export interface CountQueryBuilder<T> extends QueryBuilder<T> {
-    execute<U = {
-        count: number;
-    }[]>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
-    execute<U = {
-        count: number;
-    }[]>(method: 'all', mapResults?: boolean): Promise<U>;
-    execute<U = {
-        count: number;
-    }>(method: 'get', mapResults?: boolean): Promise<U>;
-    execute<U = QueryResult<{
-        count: number;
-    }>>(method: 'run', mapResults?: boolean): Promise<U>;
-    then<TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<number>;
-}
-export interface InsertQueryBuilder<T> extends RunQueryBuilder<T> {
-}
-export interface UpdateQueryBuilder<T> extends RunQueryBuilder<T> {
-}
-export interface DeleteQueryBuilder<T> extends RunQueryBuilder<T> {
-}
-export interface TruncateQueryBuilder<T> extends RunQueryBuilder<T> {
-}