lakutata 2.0.86 → 2.0.87

package/vendor/TypeDef.internal.373.d.ts

@@ -0,0 +1,168 @@
+import { ColumnMetadata } from './TypeDef.internal.181.js';
+import { RelationMetadata } from './TypeDef.internal.271.js';
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { EmbeddedMetadataArgs } from './TypeDef.internal.349.js';
+import { RelationIdMetadata } from './TypeDef.internal.374.js';
+import { RelationCountMetadata } from './TypeDef.internal.375.js';
+import { DataSource } from './TypeDef.internal.60.js';
+import { EntityListenerMetadata } from './TypeDef.internal.376.js';
+import { IndexMetadata } from './TypeDef.internal.377.js';
+import { UniqueMetadata } from './TypeDef.internal.378.js';
+
+/**
+ * Contains all information about entity's embedded property.
+ */
+declare class EmbeddedMetadata {
+    /**
+     * Entity metadata where this embedded is.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Parent embedded in the case if this embedded inside other embedded.
+     */
+    parentEmbeddedMetadata?: EmbeddedMetadata;
+    /**
+     * Embedded target type.
+     */
+    type: Function | string;
+    /**
+     * Property name on which this embedded is attached.
+     */
+    propertyName: string;
+    /**
+     * Gets full path to this embedded property (including embedded property name).
+     * Full path is relevant when embedded is used inside other embeds (one or multiple nested).
+     * For example it will return "counters.subcounters".
+     */
+    propertyPath: string;
+    /**
+     * Columns inside this embed.
+     */
+    columns: ColumnMetadata[];
+    /**
+     * Relations inside this embed.
+     */
+    relations: RelationMetadata[];
+    /**
+     * Entity listeners inside this embed.
+     */
+    listeners: EntityListenerMetadata[];
+    /**
+     * Indices applied to the embed columns.
+     */
+    indices: IndexMetadata[];
+    /**
+     * Uniques applied to the embed columns.
+     */
+    uniques: UniqueMetadata[];
+    /**
+     * Relation ids inside this embed.
+     */
+    relationIds: RelationIdMetadata[];
+    /**
+     * Relation counts inside this embed.
+     */
+    relationCounts: RelationCountMetadata[];
+    /**
+     * Nested embeddable in this embeddable (which has current embedded as parent embedded).
+     */
+    embeddeds: EmbeddedMetadata[];
+    /**
+     * Indicates if the entity should be instantiated using the constructor
+     * or via allocating a new object via `Object.create()`.
+     */
+    isAlwaysUsingConstructor: boolean;
+    /**
+     * Indicates if this embedded is in array mode.
+     *
+     * This option works only in mongodb.
+     */
+    isArray: boolean;
+    /**
+     * Prefix of the embedded, used instead of propertyName.
+     * If set to empty string or false, then prefix is not set at all.
+     */
+    customPrefix: string | boolean | undefined;
+    /**
+     * Gets the prefix of the columns.
+     * By default its a property name of the class where this prefix is.
+     * But if custom prefix is set then it takes its value as a prefix.
+     * However if custom prefix is set to empty string or false, then prefix to column is not applied at all.
+     */
+    prefix: string;
+    /**
+     * Returns array of property names of current embed and all its parent embeds.
+     *
+     * example: post[data][information][counters].id where "data", "information" and "counters" are embeds
+     * we need to get value of "id" column from the post real entity object.
+     * this method will return ["data", "information", "counters"]
+     */
+    parentPropertyNames: string[];
+    /**
+     * Returns array of prefixes of current embed and all its parent embeds.
+     */
+    parentPrefixes: string[];
+    /**
+     * Returns embed metadatas from all levels of the parent tree.
+     *
+     * example: post[data][information][counters].id where "data", "information" and "counters" are embeds
+     * this method will return [embed metadata of data, embed metadata of information, embed metadata of counters]
+     */
+    embeddedMetadataTree: EmbeddedMetadata[];
+    /**
+     * Embed metadatas from all levels of the parent tree.
+     *
+     * example: post[data][information][counters].id where "data", "information" and "counters" are embeds
+     * this method will return [embed metadata of data, embed metadata of information, embed metadata of counters]
+     */
+    columnsFromTree: ColumnMetadata[];
+    /**
+     * Relations of this embed and all relations from its child embeds.
+     */
+    relationsFromTree: RelationMetadata[];
+    /**
+     * Relations of this embed and all relations from its child embeds.
+     */
+    listenersFromTree: EntityListenerMetadata[];
+    /**
+     * Indices of this embed and all indices from its child embeds.
+     */
+    indicesFromTree: IndexMetadata[];
+    /**
+     * Uniques of this embed and all uniques from its child embeds.
+     */
+    uniquesFromTree: UniqueMetadata[];
+    /**
+     * Relation ids of this embed and all relation ids from its child embeds.
+     */
+    relationIdsFromTree: RelationIdMetadata[];
+    /**
+     * Relation counts of this embed and all relation counts from its child embeds.
+     */
+    relationCountsFromTree: RelationCountMetadata[];
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        args: EmbeddedMetadataArgs;
+    });
+    /**
+     * Creates a new embedded object.
+     */
+    create(options?: {
+        fromDeserializer?: boolean;
+    }): any;
+    build(connection: DataSource): this;
+    protected buildPartialPrefix(): string[];
+    protected buildPrefix(connection: DataSource): string;
+    protected buildParentPropertyNames(): string[];
+    protected buildParentPrefixes(): string[];
+    protected buildEmbeddedMetadataTree(): EmbeddedMetadata[];
+    protected buildColumnsFromTree(): ColumnMetadata[];
+    protected buildRelationsFromTree(): RelationMetadata[];
+    protected buildListenersFromTree(): EntityListenerMetadata[];
+    protected buildIndicesFromTree(): IndexMetadata[];
+    protected buildUniquesFromTree(): UniqueMetadata[];
+    protected buildRelationIdsFromTree(): RelationIdMetadata[];
+    protected buildRelationCountsFromTree(): RelationCountMetadata[];
+}
+
+export { EmbeddedMetadata };

package/vendor/TypeDef.internal.374.d.ts

@@ -0,0 +1,56 @@
+import { RelationIdMetadataArgs } from './TypeDef.internal.367.js';
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { RelationMetadata } from './TypeDef.internal.271.js';
+import { SelectQueryBuilder } from './TypeDef.internal.79.js';
+import { ObjectLiteral } from './TypeDef.internal.53.js';
+
+/**
+ * Contains all information about entity's relation count.
+ */
+declare class RelationIdMetadata {
+    /**
+     * Entity metadata where this column metadata is.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Relation from which ids will be extracted.
+     */
+    relation: RelationMetadata;
+    /**
+     * Relation name which need to count.
+     */
+    relationNameOrFactory: string | ((object: any) => any);
+    /**
+     * Target class to which metadata is applied.
+     */
+    target: Function | string;
+    /**
+     * Target's property name to which this metadata is applied.
+     */
+    propertyName: string;
+    /**
+     * Alias of the joined (destination) table.
+     */
+    alias?: string;
+    /**
+     * Extra condition applied to "ON" section of join.
+     */
+    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        args: RelationIdMetadataArgs;
+    });
+    /**
+     * Sets relation id value from the given entity.
+     *
+     * todo: make it to work in embeds as well.
+     */
+    setValue(entity: ObjectLiteral): void;
+    /**
+     * Builds some depend relation id properties.
+     * This builder method should be used only after entity metadata, its properties map and all relations are build.
+     */
+    build(): void;
+}
+
+export { RelationIdMetadata };

package/vendor/TypeDef.internal.375.d.ts

@@ -0,0 +1,49 @@
+import { RelationCountMetadataArgs } from './TypeDef.internal.364.js';
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { RelationMetadata } from './TypeDef.internal.271.js';
+import { SelectQueryBuilder } from './TypeDef.internal.79.js';
+
+/**
+ * Contains all information about entity's relation count.
+ */
+declare class RelationCountMetadata {
+    /**
+     * Entity metadata where this column metadata is.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Relation which needs to be counted.
+     */
+    relation: RelationMetadata;
+    /**
+     * Relation name which need to count.
+     */
+    relationNameOrFactory: string | ((object: any) => any);
+    /**
+     * Target class to which metadata is applied.
+     */
+    target: Function | string;
+    /**
+     * Target's property name to which this metadata is applied.
+     */
+    propertyName: string;
+    /**
+     * Alias of the joined (destination) table.
+     */
+    alias?: string;
+    /**
+     * Extra condition applied to "ON" section of join.
+     */
+    queryBuilderFactory?: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>;
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        args: RelationCountMetadataArgs;
+    });
+    /**
+     * Builds some depend relation count metadata properties.
+     * This builder method should be used only after entity metadata, its properties map and all relations are build.
+     */
+    build(): void;
+}
+
+export { RelationCountMetadata };

package/vendor/TypeDef.internal.376.d.ts

@@ -0,0 +1,51 @@
+import { EventListenerType } from './TypeDef.internal.351.js';
+import { EntityListenerMetadataArgs } from './TypeDef.internal.350.js';
+import { ObjectLiteral } from './TypeDef.internal.53.js';
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { EmbeddedMetadata } from './TypeDef.internal.373.js';
+
+/**
+ * This metadata contains all information about entity's listeners.
+ */
+declare class EntityListenerMetadata {
+    /**
+     * Entity metadata of the listener.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Embedded metadata of the listener, in the case if listener is in embedded.
+     */
+    embeddedMetadata?: EmbeddedMetadata;
+    /**
+     * Target class to which metadata is applied.
+     * This can be different then entityMetadata.target in the case if listener is in the embedded.
+     */
+    target: Function | string;
+    /**
+     * Target's property name to which this metadata is applied.
+     */
+    propertyName: string;
+    /**
+     * The type of the listener.
+     */
+    type: EventListenerType;
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        embeddedMetadata?: EmbeddedMetadata;
+        args: EntityListenerMetadataArgs;
+    });
+    /**
+     * Checks if entity listener is allowed to be executed on the given entity.
+     */
+    isAllowed(entity: ObjectLiteral): boolean;
+    /**
+     * Executes listener method of the given entity.
+     */
+    execute(entity: ObjectLiteral): any;
+    /**
+     * Calls embedded entity listener method no matter how nested it is.
+     */
+    protected callEntityEmbeddedMethod(entity: ObjectLiteral, propertyPaths: string[]): void;
+}
+
+export { EntityListenerMetadata };

package/vendor/TypeDef.internal.377.d.ts

@@ -0,0 +1,119 @@
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { IndexMetadataArgs } from './TypeDef.internal.359.js';
+import { NamingStrategyInterface } from './TypeDef.internal.66.js';
+import { ColumnMetadata } from './TypeDef.internal.181.js';
+import { EmbeddedMetadata } from './TypeDef.internal.373.js';
+
+/**
+ * Index metadata contains all information about table's index.
+ */
+declare class IndexMetadata {
+    /**
+     * Entity metadata of the class to which this index is applied.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Embedded metadata if this index was applied on embedded.
+     */
+    embeddedMetadata?: EmbeddedMetadata;
+    /**
+     * Indicates if this index must be unique.
+     */
+    isUnique: boolean;
+    /**
+     * The SPATIAL modifier indexes the entire column and does not allow indexed columns to contain NULL values.
+     * Works only in MySQL.
+     */
+    isSpatial: boolean;
+    /**
+     * The FULLTEXT modifier indexes the entire column and does not allow prefixing.
+     * Works only in MySQL.
+     */
+    isFulltext: boolean;
+    /**
+     * NULL_FILTERED indexes are particularly useful for indexing sparse columns, where most rows contain a NULL value.
+     * In these cases, the NULL_FILTERED index can be considerably smaller and more efficient to maintain than
+     * a normal index that includes NULL values.
+     *
+     * Works only in Spanner.
+     */
+    isNullFiltered: boolean;
+    /**
+     * Fulltext parser.
+     * Works only in MySQL.
+     */
+    parser?: string;
+    /**
+     * Indicates if this index must synchronize with database index.
+     */
+    synchronize: boolean;
+    /**
+     * If true, the index only references documents with the specified field.
+     * These indexes use less space but behave differently in some situations (particularly sorts).
+     * This option is only supported for mongodb database.
+     */
+    isSparse?: boolean;
+    /**
+     * Builds the index in the background so that building an index an does not block other database activities.
+     * This option is only supported for mongodb database.
+     */
+    isBackground?: boolean;
+    /**
+     * Builds the index using the concurrently option.
+     * This options is only supported for postgres database.
+     */
+    isConcurrent?: boolean;
+    /**
+     * Specifies a time to live, in seconds.
+     * This option is only supported for mongodb database.
+     */
+    expireAfterSeconds?: number;
+    /**
+     * Target class to which metadata is applied.
+     */
+    target?: Function | string;
+    /**
+     * Indexed columns.
+     */
+    columns: ColumnMetadata[];
+    /**
+     * User specified index name.
+     */
+    givenName?: string;
+    /**
+     * User specified column names.
+     */
+    givenColumnNames?: ((object?: any) => any[] | {
+        [key: string]: number;
+    }) | string[];
+    /**
+     * Final index name.
+     * If index name was given by a user then it stores normalized (by naming strategy) givenName.
+     * If index name was not given then its generated.
+     */
+    name: string;
+    /**
+     * Index filter condition.
+     */
+    where?: string;
+    /**
+     * Map of column names with order set.
+     * Used only by MongoDB driver.
+     */
+    columnNamesWithOrderingMap: {
+        [key: string]: number;
+    };
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        embeddedMetadata?: EmbeddedMetadata;
+        columns?: ColumnMetadata[];
+        args?: IndexMetadataArgs;
+    });
+    /**
+     * Builds some depend index properties.
+     * Must be called after all entity metadata's properties map, columns and relations are built.
+     */
+    build(namingStrategy: NamingStrategyInterface): this;
+}
+
+export { IndexMetadata };

package/vendor/TypeDef.internal.378.d.ts

@@ -0,0 +1,68 @@
+import { EmbeddedMetadata } from './TypeDef.internal.373.js';
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { NamingStrategyInterface } from './TypeDef.internal.66.js';
+import { ColumnMetadata } from './TypeDef.internal.181.js';
+import { UniqueMetadataArgs } from './TypeDef.internal.371.js';
+import { DeferrableType } from './TypeDef.internal.159.js';
+
+/**
+ * Unique metadata contains all information about table's unique constraints.
+ */
+declare class UniqueMetadata {
+    /**
+     * Entity metadata of the class to which this unique constraint is applied.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Embedded metadata if this unique was applied on embedded.
+     */
+    embeddedMetadata?: EmbeddedMetadata;
+    /**
+     * Target class to which metadata is applied.
+     */
+    target?: Function | string;
+    /**
+     * Unique columns.
+     */
+    columns: ColumnMetadata[];
+    /**
+     * Indicate if unique constraints can be deferred.
+     */
+    deferrable?: DeferrableType;
+    /**
+     * User specified unique constraint name.
+     */
+    givenName?: string;
+    /**
+     * User specified column names.
+     */
+    givenColumnNames?: ((object?: any) => any[] | {
+        [key: string]: number;
+    }) | string[];
+    /**
+     * Final unique constraint name.
+     * If unique constraint name was given by a user then it stores normalized (by naming strategy) givenName.
+     * If unique constraint name was not given then its generated.
+     */
+    name: string;
+    /**
+     * Map of column names with order set.
+     * Used only by MongoDB driver.
+     */
+    columnNamesWithOrderingMap: {
+        [key: string]: number;
+    };
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        embeddedMetadata?: EmbeddedMetadata;
+        columns?: ColumnMetadata[];
+        args?: UniqueMetadataArgs;
+    });
+    /**
+     * Builds some depend unique constraint properties.
+     * Must be called after all entity metadata's properties map, columns and relations are built.
+     */
+    build(namingStrategy: NamingStrategyInterface): this;
+}
+
+export { UniqueMetadata };

package/vendor/TypeDef.internal.379.d.ts

@@ -0,0 +1,80 @@
+import { ColumnMetadata } from './TypeDef.internal.181.js';
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { NamingStrategyInterface } from './TypeDef.internal.66.js';
+import { DeferrableType } from './TypeDef.internal.159.js';
+import { OnDeleteType } from './TypeDef.internal.160.js';
+import { OnUpdateType } from './TypeDef.internal.161.js';
+
+/**
+ * Contains all information about entity's foreign key.
+ */
+declare class ForeignKeyMetadata {
+    /**
+     * Entity metadata where this foreign key is.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Entity metadata which this foreign key references.
+     */
+    referencedEntityMetadata: EntityMetadata;
+    /**
+     * Array of columns of this foreign key.
+     */
+    columns: ColumnMetadata[];
+    /**
+     * Array of referenced columns.
+     */
+    referencedColumns: ColumnMetadata[];
+    /**
+     * What to do with a relation on deletion of the row containing a foreign key.
+     */
+    onDelete?: OnDeleteType;
+    /**
+     * What to do with a relation on update of the row containing a foreign key.
+     */
+    onUpdate?: OnUpdateType;
+    /**
+     * When to check the constraints of a foreign key.
+     */
+    deferrable?: DeferrableType;
+    /**
+     * Gets the table name to which this foreign key is referenced.
+     */
+    referencedTablePath: string;
+    /**
+     * Gets foreign key name.
+     * If unique constraint name was given by a user then it stores givenName.
+     * If unique constraint name was not given then its generated.
+     */
+    name: string;
+    /**
+     * Gets array of column names.
+     */
+    columnNames: string[];
+    /**
+     * Gets array of referenced column names.
+     */
+    referencedColumnNames: string[];
+    /**
+     * User specified unique constraint name.
+     */
+    givenName?: string;
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        referencedEntityMetadata: EntityMetadata;
+        namingStrategy?: NamingStrategyInterface;
+        columns: ColumnMetadata[];
+        referencedColumns: ColumnMetadata[];
+        onDelete?: OnDeleteType;
+        onUpdate?: OnUpdateType;
+        deferrable?: DeferrableType;
+        name?: string;
+    });
+    /**
+     * Builds some depend foreign key properties.
+     * Must be called after all entity metadatas and their columns are built.
+     */
+    build(namingStrategy: NamingStrategyInterface): void;
+}
+
+export { ForeignKeyMetadata };

package/vendor/TypeDef.internal.38.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/vendor/TypeDef.internal.380.d.ts

@@ -0,0 +1,42 @@
+import { EntityMetadata } from './TypeDef.internal.74.js';
+import { NamingStrategyInterface } from './TypeDef.internal.66.js';
+import { ExclusionMetadataArgs } from './TypeDef.internal.354.js';
+
+/**
+ * Exclusion metadata contains all information about table's exclusion constraints.
+ */
+declare class ExclusionMetadata {
+    /**
+     * Entity metadata of the class to which this exclusion constraint is applied.
+     */
+    entityMetadata: EntityMetadata;
+    /**
+     * Target class to which metadata is applied.
+     */
+    target?: Function | string;
+    /**
+     * Exclusion expression.
+     */
+    expression: string;
+    /**
+     * User specified exclusion constraint name.
+     */
+    givenName?: string;
+    /**
+     * Final exclusion constraint name.
+     * If exclusion constraint name was given by a user then it stores normalized (by naming strategy) givenName.
+     * If exclusion constraint name was not given then its generated.
+     */
+    name: string;
+    constructor(options: {
+        entityMetadata: EntityMetadata;
+        args?: ExclusionMetadataArgs;
+    });
+    /**
+     * Builds some depend exclusion constraint properties.
+     * Must be called after all entity metadata's properties map, columns and relations are built.
+     */
+    build(namingStrategy: NamingStrategyInterface): this;
+}
+
+export { ExclusionMetadata };