directus 9.23.4 → 9.25.0

package/dist/types/snapshot.d.ts

@@ -1,55 +0,0 @@
-import type { Field, FieldMeta, Relation, RelationMeta } from '@directus/shared/types';
-import type { Diff } from 'deep-diff';
-import type { Collection } from './collection';
-import type { DatabaseClient } from './database';
-export type Snapshot = {
-    version: number;
-    directus: string;
-    vendor?: DatabaseClient;
-    collections: Collection[];
-    fields: SnapshotField[];
-    relations: SnapshotRelation[];
-};
-export type SnapshotField = Field & {
-    meta: Omit<FieldMeta, 'id'>;
-};
-export type SnapshotRelation = Relation & {
-    meta: Omit<RelationMeta, 'id'>;
-};
-export type SnapshotWithHash = Snapshot & {
-    hash: string;
-};
-export type SnapshotDiff = {
-    collections: {
-        collection: string;
-        diff: Diff<Collection | undefined>[];
-    }[];
-    fields: {
-        collection: string;
-        field: string;
-        diff: Diff<SnapshotField | undefined>[];
-    }[];
-    relations: {
-        collection: string;
-        field: string;
-        related_collection: string | null;
-        diff: Diff<SnapshotRelation | undefined>[];
-    }[];
-};
-export type SnapshotDiffWithHash = {
-    hash: string;
-    diff: SnapshotDiff;
-};
-/**
- * Indicates the kind of change based on comparisons by deep-diff package
- */
-export declare const DiffKind: {
-    /** indicates a newly added property/element */
-    readonly NEW: "N";
-    /** indicates a property/element was deleted */
-    readonly DELETE: "D";
-    /** indicates a property/element was edited */
-    readonly EDIT: "E";
-    /** indicates a change occurred within an array */
-    readonly ARRAY: "A";
-};

package/dist/types/snapshot.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffKind = void 0;
-/**
- * Indicates the kind of change based on comparisons by deep-diff package
- */
-exports.DiffKind = {
-    /** indicates a newly added property/element */
-    NEW: 'N',
-    /** indicates a property/element was deleted */
-    DELETE: 'D',
-    /** indicates a property/element was edited */
-    EDIT: 'E',
-    /** indicates a change occurred within an array */
-    ARRAY: 'A',
-};

package/dist/types/webhooks.d.ts

@@ -1,15 +0,0 @@
-export type Webhook = {
-    id: number;
-    name: string;
-    method: 'GET' | 'POST';
-    url: string;
-    status: 'active' | 'inactive';
-    data: boolean;
-    actions: string[];
-    collections: string[];
-    headers: WebhookHeader[];
-};
-export type WebhookHeader = {
-    header: string;
-    value: string;
-};

package/dist/types/webhooks.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/apply-diff.d.ts

@@ -1,9 +0,0 @@
-import type { SchemaOverview } from '@directus/shared/types';
-import { Diff } from 'deep-diff';
-import type { Knex } from 'knex';
-import { Snapshot, SnapshotDiff, SnapshotField } from '../types';
-export declare function applyDiff(currentSnapshot: Snapshot, snapshotDiff: SnapshotDiff, options?: {
-    database?: Knex;
-    schema?: SchemaOverview;
-}): Promise<void>;
-export declare function isNestedMetaUpdate(diff: Diff<SnapshotField | undefined>): boolean;

package/dist/utils/apply-diff.js

@@ -1,256 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNestedMetaUpdate = exports.applyDiff = void 0;
-const deep_diff_1 = require("deep-diff");
-const lodash_1 = require("lodash");
-const cache_1 = require("../cache");
-const database_1 = __importDefault(require("../database"));
-const emitter_1 = __importDefault(require("../emitter"));
-const logger_1 = __importDefault(require("../logger"));
-const services_1 = require("../services");
-const types_1 = require("../types");
-const get_schema_1 = require("./get-schema");
-async function applyDiff(currentSnapshot, snapshotDiff, options) {
-    const database = options?.database ?? (0, database_1.default)();
-    const schema = options?.schema ?? (await (0, get_schema_1.getSchema)({ database, bypassCache: true }));
-    const nestedActionEvents = [];
-    const mutationOptions = {
-        autoPurgeSystemCache: false,
-        bypassEmitAction: (params) => nestedActionEvents.push(params),
-    };
-    await database.transaction(async (trx) => {
-        const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
-        const getNestedCollectionsToCreate = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].rhs?.meta?.group === currentLevelCollection);
-        const getNestedCollectionsToDelete = (currentLevelCollection) => snapshotDiff.collections.filter(({ diff }) => diff[0].lhs?.meta?.group === currentLevelCollection);
-        const createCollections = async (collections) => {
-            for (const { collection, diff } of collections) {
-                if (diff?.[0].kind === types_1.DiffKind.NEW && diff[0].rhs) {
-                    // We'll nest the to-be-created fields in the same collection creation, to prevent
-                    // creating a collection without a primary key
-                    const fields = snapshotDiff.fields
-                        .filter((fieldDiff) => fieldDiff.collection === collection)
-                        .map((fieldDiff) => fieldDiff.diff[0].rhs)
-                        .map((fieldDiff) => {
-                        // Casts field type to UUID when applying non-PostgreSQL schema onto PostgreSQL database.
-                        // This is needed because they snapshots UUID fields as char/varchar with length 36.
-                        if (['char', 'varchar'].includes(String(fieldDiff.schema?.data_type).toLowerCase()) &&
-                            fieldDiff.schema?.max_length === 36 &&
-                            (fieldDiff.schema?.is_primary_key ||
-                                (fieldDiff.schema?.foreign_key_table && fieldDiff.schema?.foreign_key_column))) {
-                            return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
-                        }
-                        else {
-                            return fieldDiff;
-                        }
-                    });
-                    try {
-                        await collectionsService.createOne({
-                            ...diff[0].rhs,
-                            fields,
-                        }, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to create collection "${collection}"`);
-                        throw err;
-                    }
-                    // Now that the fields are in for this collection, we can strip them from the field edits
-                    snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
-                    await createCollections(getNestedCollectionsToCreate(collection));
-                }
-            }
-        };
-        const deleteCollections = async (collections) => {
-            for (const { collection, diff } of collections) {
-                if (diff?.[0].kind === types_1.DiffKind.DELETE) {
-                    const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
-                    if (relations.length > 0) {
-                        const relationsService = new services_1.RelationsService({ knex: trx, schema });
-                        for (const relation of relations) {
-                            try {
-                                await relationsService.deleteOne(relation.collection, relation.field, mutationOptions);
-                            }
-                            catch (err) {
-                                logger_1.default.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
-                                throw err;
-                            }
-                        }
-                        // clean up deleted relations from existing schema
-                        schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
-                    }
-                    await deleteCollections(getNestedCollectionsToDelete(collection));
-                    try {
-                        await collectionsService.deleteOne(collection, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to delete collection "${collection}"`);
-                        throw err;
-                    }
-                }
-            }
-        };
-        // Finds all collections that need to be created
-        const filterCollectionsForCreation = ({ diff }) => {
-            // Check new collections only
-            const isNewCollection = diff[0].kind === types_1.DiffKind.NEW;
-            if (!isNewCollection)
-                return false;
-            // Create now if no group
-            const groupName = diff[0].rhs.meta?.group;
-            if (!groupName)
-                return true;
-            // Check if parent collection already exists in schema
-            const parentExists = currentSnapshot.collections.find((c) => c.collection === groupName) !== undefined;
-            // If this is a new collection and the parent collection doesn't exist in current schema ->
-            // Check if the parent collection will be created as part of applying this snapshot ->
-            // If yes -> this collection will be created recursively
-            // If not -> create now
-            // (ex.)
-            // TopLevelCollection - I exist in current schema
-            // 		NestedCollection - I exist in snapshotDiff as a new collection
-            //			TheCurrentCollectionInIteration - I exist in snapshotDiff as a new collection but will be created as part of NestedCollection
-            const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff }) => diff[0].kind === types_1.DiffKind.NEW && collection === groupName).length > 0;
-            // Has group, but parent is not new, parent is also not being created in this snapshot apply
-            if (parentExists && !parentWillBeCreatedInThisApply)
-                return true;
-            return false;
-        };
-        // Create top level collections (no group, or highest level in existing group) first,
-        // then continue with nested collections recursively
-        await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
-        // delete top level collections (no group) first, then continue with nested collections recursively
-        await deleteCollections(snapshotDiff.collections.filter(({ diff }) => diff[0].kind === types_1.DiffKind.DELETE && diff[0].lhs.meta?.group === null));
-        for (const { collection, diff } of snapshotDiff.collections) {
-            if (diff?.[0].kind === types_1.DiffKind.EDIT || diff?.[0].kind === types_1.DiffKind.ARRAY) {
-                const currentCollection = currentSnapshot.collections.find((field) => {
-                    return field.collection === collection;
-                });
-                if (currentCollection) {
-                    try {
-                        const newValues = diff.reduce((acc, currentDiff) => {
-                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
-                            return acc;
-                        }, (0, lodash_1.cloneDeep)(currentCollection));
-                        await collectionsService.updateOne(collection, newValues, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to update collection "${collection}"`);
-                        throw err;
-                    }
-                }
-            }
-        }
-        const fieldsService = new services_1.FieldsService({
-            knex: trx,
-            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
-        });
-        for (const { collection, field, diff } of snapshotDiff.fields) {
-            if (diff?.[0].kind === types_1.DiffKind.NEW && !isNestedMetaUpdate(diff?.[0])) {
-                try {
-                    await fieldsService.createField(collection, diff[0].rhs, undefined, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to create field "${collection}.${field}"`);
-                    throw err;
-                }
-            }
-            if (diff?.[0].kind === types_1.DiffKind.EDIT || diff?.[0].kind === types_1.DiffKind.ARRAY || isNestedMetaUpdate(diff?.[0])) {
-                const currentField = currentSnapshot.fields.find((snapshotField) => {
-                    return snapshotField.collection === collection && snapshotField.field === field;
-                });
-                if (currentField) {
-                    try {
-                        const newValues = diff.reduce((acc, currentDiff) => {
-                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
-                            return acc;
-                        }, (0, lodash_1.cloneDeep)(currentField));
-                        await fieldsService.updateField(collection, newValues, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to update field "${collection}.${field}"`);
-                        throw err;
-                    }
-                }
-            }
-            if (diff?.[0].kind === types_1.DiffKind.DELETE && !isNestedMetaUpdate(diff?.[0])) {
-                try {
-                    await fieldsService.deleteField(collection, field, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to delete field "${collection}.${field}"`);
-                    throw err;
-                }
-                // Field deletion also cleans up the relationship. We should ignore any relationship
-                // changes attached to this now non-existing field
-                snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field) === false);
-            }
-        }
-        const relationsService = new services_1.RelationsService({
-            knex: trx,
-            schema: await (0, get_schema_1.getSchema)({ database: trx, bypassCache: true }),
-        });
-        for (const { collection, field, diff } of snapshotDiff.relations) {
-            const structure = {};
-            for (const diffEdit of diff) {
-                (0, lodash_1.set)(structure, diffEdit.path, undefined);
-            }
-            if (diff?.[0].kind === types_1.DiffKind.NEW) {
-                try {
-                    await relationsService.createOne(diff[0].rhs, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to create relation "${collection}.${field}"`);
-                    throw err;
-                }
-            }
-            if (diff?.[0].kind === types_1.DiffKind.EDIT || diff?.[0].kind === types_1.DiffKind.ARRAY) {
-                const currentRelation = currentSnapshot.relations.find((relation) => {
-                    return relation.collection === collection && relation.field === field;
-                });
-                if (currentRelation) {
-                    try {
-                        const newValues = diff.reduce((acc, currentDiff) => {
-                            (0, deep_diff_1.applyChange)(acc, undefined, currentDiff);
-                            return acc;
-                        }, (0, lodash_1.cloneDeep)(currentRelation));
-                        await relationsService.updateOne(collection, field, newValues, mutationOptions);
-                    }
-                    catch (err) {
-                        logger_1.default.error(`Failed to update relation "${collection}.${field}"`);
-                        throw err;
-                    }
-                }
-            }
-            if (diff?.[0].kind === types_1.DiffKind.DELETE) {
-                try {
-                    await relationsService.deleteOne(collection, field, mutationOptions);
-                }
-                catch (err) {
-                    logger_1.default.error(`Failed to delete relation "${collection}.${field}"`);
-                    throw err;
-                }
-            }
-        }
-    });
-    await (0, cache_1.clearSystemCache)();
-    if (nestedActionEvents.length > 0) {
-        const updatedSchema = await (0, get_schema_1.getSchema)({ database, bypassCache: true });
-        for (const nestedActionEvent of nestedActionEvents) {
-            nestedActionEvent.context.schema = updatedSchema;
-            emitter_1.default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
-        }
-    }
-}
-exports.applyDiff = applyDiff;
-function isNestedMetaUpdate(diff) {
-    if (!diff)
-        return false;
-    if (diff.kind !== types_1.DiffKind.NEW && diff.kind !== types_1.DiffKind.DELETE)
-        return false;
-    if (!diff.path || diff.path.length < 2 || diff.path[0] !== 'meta')
-        return false;
-    return true;
-}
-exports.isNestedMetaUpdate = isNestedMetaUpdate;

package/dist/utils/apply-diff.test.d.ts

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

package/dist/utils/apply-function-to-column-name.d.ts

@@ -1,12 +0,0 @@
-/**
- * Takes in a column name, and transforms the original name with the generated column name based on
- * the applied function.
- *
- * @example
- *
- * ```js
- * applyFunctionToColumnName('year(date_created)');
- * // => "date_created_year"
- * ```
- */
-export declare function applyFunctionToColumnName(column: string): string;

package/dist/utils/apply-function-to-column-name.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyFunctionToColumnName = void 0;
-const constants_1 = require("@directus/shared/constants");
-/**
- * Takes in a column name, and transforms the original name with the generated column name based on
- * the applied function.
- *
- * @example
- *
- * ```js
- * applyFunctionToColumnName('year(date_created)');
- * // => "date_created_year"
- * ```
- */
-function applyFunctionToColumnName(column) {
-    if (column.includes('(') && column.includes(')')) {
-        const functionName = column.split('(')[0];
-        const columnName = column.match(constants_1.REGEX_BETWEEN_PARENS)[1];
-        return `${columnName}_${functionName}`;
-    }
-    else {
-        return column;
-    }
-}
-exports.applyFunctionToColumnName = applyFunctionToColumnName;

package/dist/utils/apply-function-to-column-name.test.d.ts

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

package/dist/utils/apply-query.d.ts

@@ -1,34 +0,0 @@
-import type { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
-import type { Knex } from 'knex';
-import { AliasMap } from './get-column-path';
-export declare const generateAlias: (size?: number | undefined) => string;
-/**
- * Apply the Query to a given Knex query builder instance
- */
-export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, options?: {
-    aliasMap?: AliasMap;
-    isInnerQuery?: boolean;
-    hasMultiRelationalSort?: boolean | undefined;
-}): {
-    query: Knex.QueryBuilder<any, any>;
-    hasMultiRelationalFilter: boolean;
-};
-export type ColumnSortRecord = {
-    order: 'asc' | 'desc';
-    column: string;
-};
-export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, aliasMap: AliasMap, returnRecords?: boolean): {
-    sortRecords: {
-        order: "asc" | "desc";
-        column: any;
-    }[];
-    hasMultiRelationalSort: boolean;
-} | undefined;
-export declare function applyLimit(knex: Knex, rootQuery: Knex.QueryBuilder, limit: any): void;
-export declare function applyOffset(knex: Knex, rootQuery: Knex.QueryBuilder, offset: any): void;
-export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, aliasMap: AliasMap): {
-    query: Knex.QueryBuilder<any, any>;
-    hasMultiRelationalFilter: boolean;
-};
-export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
-export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;