taon-typeorm 21.0.2 → 21.0.6

package/websql/index.d.ts

@@ -1,6 +0,0 @@
-// @ts-nocheck
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="taon-typeorm" />
-export * from './public-api';

package/websql/lib/index.d.ts

@@ -1,2 +0,0 @@
-// @ts-nocheck
-export * from './typeorm';

package/websql/lib/typeorm/cache/DbQueryResultCache.d.ts

@@ -1,53 +0,0 @@
-// @ts-nocheck
-import { DataSource } from "../data-source/DataSource";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { QueryResultCache } from "./QueryResultCache";
-import { QueryResultCacheOptions } from "./QueryResultCacheOptions";
-/**
- * Caches query result into current database, into separate table called "query-result-cache".
- */
-export declare class DbQueryResultCache implements QueryResultCache {
-    protected connection: DataSource;
-    private queryResultCacheTable;
-    private queryResultCacheDatabase?;
-    private queryResultCacheSchema?;
-    constructor(connection: DataSource);
-    /**
-     * Creates a connection with given cache provider.
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnects with given cache provider.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Creates table for storing cache if it does not exist yet.
-     */
-    synchronize(queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Caches given query result.
-     * Returns cache result if found.
-     * Returns undefined if result is not cached.
-     */
-    getFromCache(options: QueryResultCacheOptions, queryRunner?: QueryRunner): Promise<QueryResultCacheOptions | undefined>;
-    /**
-     * Checks if cache is expired or not.
-     */
-    isExpired(savedCache: QueryResultCacheOptions): boolean;
-    /**
-     * Stores given query result in the cache.
-     */
-    storeInCache(options: QueryResultCacheOptions, savedCache: QueryResultCacheOptions | undefined, queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Clears everything stored in the cache.
-     */
-    clear(queryRunner: QueryRunner): Promise<void>;
-    /**
-     * Removes all cached results by given identifiers from cache.
-     */
-    remove(identifiers: string[], queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Gets a query runner to work with.
-     */
-    protected getQueryRunner(queryRunner?: QueryRunner): QueryRunner;
-}

package/websql/lib/typeorm/cache/QueryResultCache.d.ts

@@ -1,40 +0,0 @@
-// @ts-nocheck
-import { QueryResultCacheOptions } from "./QueryResultCacheOptions";
-import { QueryRunner } from "../query-runner/QueryRunner";
-/**
- * Implementations of this interface provide different strategies to cache query builder results.
- */
-export interface QueryResultCache {
-    /**
-     * Creates a connection with given cache provider.
-     */
-    connect(): Promise<void>;
-    /**
-     * Closes a connection with given cache provider.
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Performs operations needs to be created during schema synchronization.
-     */
-    synchronize(queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Caches given query result.
-     */
-    getFromCache(options: QueryResultCacheOptions, queryRunner?: QueryRunner): Promise<QueryResultCacheOptions | undefined>;
-    /**
-     * Stores given query result in the cache.
-     */
-    storeInCache(options: QueryResultCacheOptions, savedCache: QueryResultCacheOptions | undefined, queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Checks if cache is expired or not.
-     */
-    isExpired(savedCache: QueryResultCacheOptions): boolean;
-    /**
-     * Clears everything stored in the cache.
-     */
-    clear(queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Removes all cached results by given identifiers from cache.
-     */
-    remove(identifiers: string[], queryRunner?: QueryRunner): Promise<void>;
-}

package/websql/lib/typeorm/cache/QueryResultCacheFactory.d.ts

@@ -1,14 +0,0 @@
-// @ts-nocheck
-import { QueryResultCache } from "./QueryResultCache";
-import { DataSource } from "../data-source/DataSource";
-/**
- * Caches query result into Redis database.
- */
-export declare class QueryResultCacheFactory {
-    protected connection: DataSource;
-    constructor(connection: DataSource);
-    /**
-     * Creates a new query result cache based on connection options.
-     */
-    create(): QueryResultCache;
-}

package/websql/lib/typeorm/cache/QueryResultCacheOptions.d.ts

@@ -1,27 +0,0 @@
-// @ts-nocheck
-/**
- * Options passed to QueryResultCache class.
- */
-export interface QueryResultCacheOptions {
-    /**
-     * Cache identifier set by user.
-     * Can be empty.
-     */
-    identifier: string;
-    /**
-     * Time, when cache was created.
-     */
-    time?: number;
-    /**
-     * Duration in milliseconds during which results will be returned from cache.
-     */
-    duration: number;
-    /**
-     * Cached query.
-     */
-    query: string;
-    /**
-     * Query result that will be cached.
-     */
-    result?: any;
-}

package/websql/lib/typeorm/cache/RedisQueryResultCache.d.ts

@@ -1,66 +0,0 @@
-// @ts-nocheck
-import { QueryResultCache } from "./QueryResultCache";
-import { QueryResultCacheOptions } from "./QueryResultCacheOptions";
-import { DataSource } from "../data-source/DataSource";
-import { QueryRunner } from "../query-runner/QueryRunner";
-/**
- * Caches query result into Redis database.
- */
-export declare class RedisQueryResultCache implements QueryResultCache {
-    protected connection: DataSource;
-    /**
-     * Redis module instance loaded dynamically.
-     */
-    protected redis: any;
-    /**
-     * Connected redis client.
-     */
-    protected client: any;
-    /**
-     * Type of the Redis Client (redis or ioredis).
-     */
-    protected clientType: "redis" | "ioredis" | "ioredis/cluster";
-    constructor(connection: DataSource, clientType: "redis" | "ioredis" | "ioredis/cluster");
-    /**
-     * Creates a connection with given cache provider.
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnects the connection
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Creates table for storing cache if it does not exist yet.
-     */
-    synchronize(queryRunner: QueryRunner): Promise<void>;
-    /**
-     * Caches given query result.
-     * Returns cache result if found.
-     * Returns undefined if result is not cached.
-     */
-    getFromCache(options: QueryResultCacheOptions, queryRunner?: QueryRunner): Promise<QueryResultCacheOptions | undefined>;
-    /**
-     * Checks if cache is expired or not.
-     */
-    isExpired(savedCache: QueryResultCacheOptions): boolean;
-    /**
-     * Stores given query result in the cache.
-     */
-    storeInCache(options: QueryResultCacheOptions, savedCache: QueryResultCacheOptions, queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Clears everything stored in the cache.
-     */
-    clear(queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Removes all cached results by given identifiers from cache.
-     */
-    remove(identifiers: string[], queryRunner?: QueryRunner): Promise<void>;
-    /**
-     * Removes a single key from redis database.
-     */
-    protected deleteKey(key: string): Promise<void>;
-    /**
-     * Loads redis dependency.
-     */
-    protected loadRedis(): any;
-}

package/websql/lib/typeorm/common/DeepPartial.d.ts

@@ -1,7 +0,0 @@
-// @ts-nocheck
-/**
- * Same as Partial<T> but goes deeper and makes Partial<T> all its properties and sub-properties.
- */
-export type DeepPartial<T> = T | (T extends Array<infer U> ? DeepPartial<U>[] : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer M> ? Set<DeepPartial<M>> : T extends object ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T);

package/websql/lib/typeorm/common/EntityTarget.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-import { ObjectType } from "./ObjectType";
-import { EntitySchema } from "..";
-/**
- * Entity target.
- */
-export type EntityTarget<Entity> = ObjectType<Entity> | EntitySchema<Entity> | string | {
-    type: Entity;
-    name: string;
-};

package/websql/lib/typeorm/common/MixedList.d.ts

@@ -1,9 +0,0 @@
-// @ts-nocheck
-/**
- * List of T-s passed as an array or object map.
- *
- * Example usage: entities as an array of imported using import * as syntax.
- */
-export type MixedList<T> = T[] | {
-    [key: string]: T;
-};

package/websql/lib/typeorm/common/ObjectLiteral.d.ts

@@ -1,7 +0,0 @@
-// @ts-nocheck
-/**
- * Interface of the simple literal object with any string keys.
- */
-export interface ObjectLiteral {
-    [key: string]: any;
-}

package/websql/lib/typeorm/common/ObjectType.d.ts

@@ -1,7 +0,0 @@
-// @ts-nocheck
-/**
- * Represents some Type of the Object.
- */
-export type ObjectType<T> = {
-    new (): T;
-} | Function;

package/websql/lib/typeorm/common/RelationType.d.ts

@@ -1,15 +0,0 @@
-// @ts-nocheck
-/**
- * Wrapper type for relation type definitions in entities.
- * Used to circumvent ESM modules circular dependency issue caused by reflection metadata saving the type of the property.
- *
- * Usage example:
- * @Entity()
- * export default class User {
- *
- *     @OneToOne(() => Profile, profile => profile.user)
- *     profile: Relation<Profile>;
- *
- * }
- */
-export type Relation<T> = T;

package/websql/lib/typeorm/connection/Connection.d.ts

@@ -1,11 +0,0 @@
-// @ts-nocheck
-import { DataSource } from "../data-source/DataSource";
-/**
- * Connection is a single database ORM connection to a specific database.
- * Its not required to be a database connection, depend on database type it can create connection pool.
- * You can have multiple connections to multiple databases in your application.
- *
- * @deprecated
- */
-export declare class Connection extends DataSource {
-}

package/websql/lib/typeorm/connection/ConnectionManager.d.ts

@@ -1,34 +0,0 @@
-// @ts-nocheck
-import { DataSource } from "../data-source/DataSource";
-import { DataSourceOptions } from "../data-source/DataSourceOptions";
-/**
- * ConnectionManager is used to store and manage multiple orm connections.
- * It also provides useful factory methods to simplify connection creation.
- *
- * @deprecated
- */
-export declare class ConnectionManager {
-    /**
-     * List of connections registered in this connection manager.
-     */
-    get connections(): DataSource[];
-    /**
-     * Internal lookup to quickly get from a connection name to the Connection object.
-     */
-    private readonly connectionMap;
-    /**
-     * Checks if connection with the given name exist in the manager.
-     */
-    has(name: string): boolean;
-    /**
-     * Gets registered connection with the given name.
-     * If connection name is not given then it will get a default connection.
-     * Throws error if connection with the given name was not found.
-     */
-    get(name?: string): DataSource;
-    /**
-     * Creates a new connection based on the given connection options and registers it in the manager.
-     * Connection won't be established, you'll need to manually call connect method to establish connection.
-     */
-    create(options: DataSourceOptions): DataSource;
-}

package/websql/lib/typeorm/connection/ConnectionMetadataBuilder.d.ts

@@ -1,25 +0,0 @@
-// @ts-nocheck
-import { MigrationInterface } from "../migration/MigrationInterface";
-import { DataSource } from "../data-source/DataSource";
-import { EntitySchema } from "../entity-schema/EntitySchema";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { EntitySubscriberInterface } from "../subscriber/EntitySubscriberInterface";
-/**
- * Builds migration instances, subscriber instances and entity metadatas for the given classes.
- */
-export declare class ConnectionMetadataBuilder {
-    protected connection: DataSource;
-    constructor(connection: DataSource);
-    /**
-     * Builds migration instances for the given classes or directories.
-     */
-    buildMigrations(migrations: (Function | string)[]): Promise<MigrationInterface[]>;
-    /**
-     * Builds subscriber instances for the given classes or directories.
-     */
-    buildSubscribers(subscribers: (Function | string)[]): Promise<EntitySubscriberInterface<any>[]>;
-    /**
-     * Builds entity metadatas for the given classes or directories.
-     */
-    buildEntityMetadatas(entities: (Function | EntitySchema<any> | string)[]): Promise<EntityMetadata[]>;
-}

package/websql/lib/typeorm/connection/ConnectionOptions.d.ts

@@ -1,10 +0,0 @@
-// @ts-nocheck
-import { DataSourceOptions } from "../data-source/DataSourceOptions";
-/**
- * ConnectionOptions is an interface with settings and options for specific connection.
- * Options contain database and other connection-related settings.
- * Consumer must provide connection options for each of your connections.
- *
- * @deprecated use DataSourceOptions instead
- */
-export type ConnectionOptions = DataSourceOptions;

package/websql/lib/typeorm/connection/ConnectionOptionsReader.d.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-import { DataSourceOptions } from "../data-source/DataSourceOptions";
-/**
- * Reads connection options from the ormconfig.
- * Can read from multiple file extensions including env, json, js, xml and yml.
- */
-export declare class ConnectionOptionsReader {
-    protected options?: {
-        /**
-         * Directory where ormconfig should be read from.
-         * By default its your application root (where your app package.json is located).
-         */
-        root?: string;
-        /**
-         * Filename of the ormconfig configuration. By default its equal to "ormconfig".
-         */
-        configName?: string;
-    };
-    constructor(options?: {
-        /**
-         * Directory where ormconfig should be read from.
-         * By default its your application root (where your app package.json is located).
-         */
-        root?: string;
-        /**
-         * Filename of the ormconfig configuration. By default its equal to "ormconfig".
-         */
-        configName?: string;
-    });
-    /**
-     * Returns all connection options read from the ormconfig.
-     */
-    all(): Promise<DataSourceOptions[]>;
-    /**
-     * Gets a connection with a given name read from ormconfig.
-     * If connection with such name would not be found then it throw error.
-     */
-    get(name: string): Promise<DataSourceOptions>;
-    /**
-     * Checks if there is a TypeORM configuration file.
-     */
-    has(name: string): Promise<boolean>;
-    /**
-     * Loads all connection options from a configuration file.
-     *
-     * todo: get in count NODE_ENV somehow
-     */
-    protected load(): Promise<DataSourceOptions[] | undefined>;
-    /**
-     * Normalize connection options.
-     */
-    protected normalizeConnectionOptions(connectionOptions: DataSourceOptions | DataSourceOptions[]): DataSourceOptions[];
-    /**
-     * Gets directory where configuration file should be located and configuration file name.
-     */
-    protected get baseFilePath(): string;
-    /**
-     * Gets directory where configuration file should be located.
-     */
-    protected get baseDirectory(): string;
-    /**
-     * Gets configuration file name.
-     */
-    protected get baseConfigName(): string;
-}

package/websql/lib/typeorm/constants.d.ts

@@ -1,2 +0,0 @@
-// @ts-nocheck
-export declare const OrignalClassKey = "$$originalClass$$";

package/websql/lib/typeorm/container.d.ts

@@ -1,40 +0,0 @@
-// @ts-nocheck
-/**
- * Container options.
- *
- * @deprecated
- */
-export interface UseContainerOptions {
-    /**
-     * If set to true, then default container will be used in the case if given container haven't returned anything.
-     */
-    fallback?: boolean;
-    /**
-     * If set to true, then default container will be used in the case if given container thrown an exception.
-     */
-    fallbackOnErrors?: boolean;
-}
-/**
- * @deprecated
- */
-export type ContainedType<T> = {
-    new (...args: any[]): T;
-} | Function;
-/**
- * @deprecated
- */
-export interface ContainerInterface {
-    get<T>(someClass: ContainedType<T>): T;
-}
-/**
- * Sets container to be used by this library.
- *
- * @deprecated
- */
-export declare function useContainer(iocContainer: ContainerInterface, options?: UseContainerOptions): void;
-/**
- * Gets the IOC container used by this library.
- *
- * @deprecated
- */
-export declare function getFromContainer<T>(someClass: ContainedType<T>): T;

package/websql/lib/typeorm/data-source/BaseDataSourceOptions.d.ts

@@ -1,172 +0,0 @@
-// @ts-nocheck
-import { EntitySchema } from "../entity-schema/EntitySchema";
-import { LoggerOptions } from "../logger/LoggerOptions";
-import { NamingStrategyInterface } from "../naming-strategy/NamingStrategyInterface";
-import { DatabaseType } from "../driver/types/DatabaseType";
-import { Logger } from "../logger/Logger";
-import { DataSource } from "../data-source/DataSource";
-import { QueryResultCache } from "../cache/QueryResultCache";
-import { MixedList } from "../common/MixedList";
-/**
- * BaseDataSourceOptions is set of DataSourceOptions shared by all database types.
- */
-export interface BaseDataSourceOptions {
-    /**
-     * Database type. This value is required.
-     */
-    readonly type: DatabaseType;
-    /**
-     * Connection name. If connection name is not given then it will be called "default".
-     * Different connections must have different names.
-     *
-     * @deprecated
-     */
-    readonly name?: string;
-    /**
-     * Entities to be loaded for this connection.
-     * Accepts both entity classes and directories where from entities need to be loaded.
-     * Directories support glob patterns.
-     */
-    readonly entities?: MixedList<Function | string | EntitySchema>;
-    /**
-     * Subscribers to be loaded for this connection.
-     * Accepts both subscriber classes and directories where from subscribers need to be loaded.
-     * Directories support glob patterns.
-     */
-    readonly subscribers?: MixedList<Function | string>;
-    /**
-     * Migrations to be loaded for this connection.
-     * Accepts both migration classes and glob patterns representing migration files.
-     */
-    readonly migrations?: MixedList<Function | string>;
-    /**
-     * Migrations table name, in case of different name from "migrations".
-     * Accepts single string name.
-     */
-    readonly migrationsTableName?: string;
-    /**
-     * Transaction mode for migrations to run in
-     */
-    readonly migrationsTransactionMode?: "all" | "none" | "each";
-    /**
-     * Typeorm metadata table name, in case of different name from "typeorm_metadata".
-     * Accepts single string name.
-     */
-    readonly metadataTableName?: string;
-    /**
-     * Naming strategy to be used to name tables and columns in the database.
-     */
-    readonly namingStrategy?: NamingStrategyInterface;
-    /**
-     * Logging options.
-     */
-    readonly logging?: LoggerOptions;
-    /**
-     * Logger instance used to log queries and events in the ORM.
-     */
-    readonly logger?: "advanced-console" | "simple-console" | "file" | "debug" | Logger;
-    /**
-     * Maximum number of milliseconds query should be executed before logger log a warning.
-     */
-    readonly maxQueryExecutionTime?: number;
-    /**
-     * Maximum number of clients the pool should contain.
-     */
-    readonly poolSize?: number;
-    /**
-     * Indicates if database schema should be auto created on every application launch.
-     * Be careful with this option and don't use this in production - otherwise you can lose production data.
-     * This option is useful during debug and development.
-     * Alternative to it, you can use CLI and run schema:sync command.
-     *
-     * Note that for MongoDB database it does not create schema, because MongoDB is schemaless.
-     * Instead, it syncs just by creating indices.
-     */
-    readonly synchronize?: boolean;
-    /**
-     * Indicates if migrations should be auto run on every application launch.
-     * Alternative to it, you can use CLI and run migrations:run command.
-     */
-    readonly migrationsRun?: boolean;
-    /**
-     * Drops the schema each time connection is being established.
-     * Be careful with this option and don't use this in production - otherwise you'll lose all production data.
-     * This option is useful during debug and development.
-     */
-    readonly dropSchema?: boolean;
-    /**
-     * Prefix to use on all tables (collections) of this connection in the database.
-     */
-    readonly entityPrefix?: string;
-    /**
-     * When creating new Entity instances, skip all constructors when true.
-     */
-    readonly entitySkipConstructor?: boolean;
-    /**
-     * Extra connection options to be passed to the underlying driver.
-     *
-     * todo: deprecate this and move all database-specific types into hts own connection options object.
-     */
-    readonly extra?: any;
-    /**
-     * Specifies how relations must be loaded - using "joins" or separate queries.
-     * If you are loading too much data with nested joins it's better to load relations
-     * using separate queries.
-     *
-     * Default strategy is "join", but this default can be changed here.
-     * Also, strategy can be set per-query in FindOptions and QueryBuilder.
-     */
-    readonly relationLoadStrategy?: "join" | "query";
-    /**
-     * Optionally applied "typename" to the model.
-     * If set, then each hydrated model will have this property with the target model / entity name inside.
-     *
-     * (works like a discriminator property).
-     */
-    readonly typename?: string;
-    /**
-     * Holds reference to the baseDirectory where configuration file are expected.
-     *
-     * @internal
-     */
-    baseDirectory?: string;
-    /**
-     * Allows to setup cache options.
-     */
-    readonly cache?: boolean | {
-        /**
-         * Type of caching.
-         *
-         * - "database" means cached values will be stored in the separate table in database. This is default value.
-         * - "redis" means cached values will be stored inside redis. You must provide redis connection options.
-         */
-        readonly type?: "database" | "redis" | "ioredis" | "ioredis/cluster";
-        /**
-         * Factory function for custom cache providers that implement QueryResultCache.
-         */
-        readonly provider?: (connection: DataSource) => QueryResultCache;
-        /**
-         * Configurable table name for "database" type cache.
-         * Default value is "query-result-cache"
-         */
-        readonly tableName?: string;
-        /**
-         * Used to provide redis connection options.
-         */
-        readonly options?: any;
-        /**
-         * If set to true then queries (using find methods and QueryBuilder's methods) will always be cached.
-         */
-        readonly alwaysEnabled?: boolean;
-        /**
-         * Time in milliseconds in which cache will expire.
-         * This can be setup per-query.
-         * Default value is 1000 which is equivalent to 1 second.
-         */
-        readonly duration?: number;
-        /**
-         * Used to specify if cache errors should be ignored, and pass through the call to the Database.
-         */
-        readonly ignoreErrors?: boolean;
-    };
-}