@directus/api 23.0.0 → 23.1.0

package/dist/services/graphql/index.js

@@ -1,4 +1,4 @@
-import { Action, FUNCTIONS } from '@directus/constants';
+import { FUNCTIONS } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import { isSystemCollection } from '@directus/system-data';
@@ -11,6 +11,8 @@ import { clearSystemCache, getCache } from '../../cache.js';
 import { DEFAULT_AUTH_PROVIDER, GENERATE_SPECIAL, REFRESH_COOKIE_OPTIONS, SESSION_COOKIE_OPTIONS, } from '../../constants.js';
 import getDatabase from '../../database/index.js';
 import { rateLimiter } from '../../middleware/rate-limiter-registration.js';
+import { fetchAccountabilityCollectionAccess } from '../../permissions/modules/fetch-accountability-collection-access/fetch-accountability-collection-access.js';
+import { fetchAccountabilityPolicyGlobals } from '../../permissions/modules/fetch-accountability-policy-globals/fetch-accountability-policy-globals.js';
 import { fetchAllowedFieldMap } from '../../permissions/modules/fetch-allowed-field-map/fetch-allowed-field-map.js';
 import { fetchInconsistentFieldMap } from '../../permissions/modules/fetch-inconsistent-field-map/fetch-inconsistent-field-map.js';
 import { createDefaultAccountability } from '../../permissions/utils/create-default-accountability.js';
@@ -25,14 +27,15 @@ import { mergeVersionsRaw, mergeVersionsRecursive } from '../../utils/merge-vers
 import { reduceSchema } from '../../utils/reduce-schema.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
 import { validateQuery } from '../../utils/validate-query.js';
-import { ActivityService } from '../activity.js';
 import { AuthenticationService } from '../authentication.js';
 import { CollectionsService } from '../collections.js';
+import { CommentsService } from '../comments.js';
 import { ExtensionsService } from '../extensions.js';
 import { FieldsService } from '../fields.js';
 import { FilesService } from '../files.js';
 import { RelationsService } from '../relations.js';
 import { RevisionsService } from '../revisions.js';
+import { RolesService } from '../roles.js';
 import { ServerService } from '../server.js';
 import { SpecificationService } from '../specifications.js';
 import { TFAService } from '../tfa.js';
@@ -51,9 +54,6 @@ import { GraphQLVoid } from './types/void.js';
 import { addPathToValidationError } from './utils/add-path-to-validation-error.js';
 import processError from './utils/process-error.js';
 import { sanitizeGraphqlSchema } from './utils/sanitize-gql-schema.js';
-import { fetchAccountabilityCollectionAccess } from '../../permissions/modules/fetch-accountability-collection-access/fetch-accountability-collection-access.js';
-import { fetchAccountabilityPolicyGlobals } from '../../permissions/modules/fetch-accountability-policy-globals/fetch-accountability-policy-globals.js';
-import { RolesService } from '../roles.js';
 const env = useEnv();
 const validationRules = Array.from(specifiedRules);
 if (env['GRAPHQL_INTROSPECTION'] === false) {
@@ -2313,6 +2313,9 @@ export class GraphQLService {
                         max_length: GraphQLInt,
                         numeric_precision: GraphQLInt,
                         numeric_scale: GraphQLInt,
+                        is_generated: GraphQLBoolean,
+                        generation_expression: GraphQLString,
+                        is_indexed: GraphQLBoolean,
                         is_nullable: GraphQLBoolean,
                         is_unique: GraphQLBoolean,
                         is_primary_key: GraphQLBoolean,
@@ -2771,17 +2774,13 @@ export class GraphQLService {
                         comment: new GraphQLNonNull(GraphQLString),
                     },
                     resolve: async (_, args, __, info) => {
-                        const service = new ActivityService({
+                        const service = new CommentsService({
                             accountability: this.accountability,
                             schema: this.schema,
+                            serviceOrigin: 'activity',
                         });
                         const primaryKey = await service.createOne({
                             ...args,
-                            action: Action.COMMENT,
-                            user: this.accountability?.user,
-                            ip: this.accountability?.ip,
-                            user_agent: this.accountability?.userAgent,
-                            origin: this.accountability?.origin,
                         });
                         if ('directus_activity' in ReadCollectionTypes) {
                             const selections = this.replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
@@ -2802,15 +2801,16 @@ export class GraphQLService {
                         comment: new GraphQLNonNull(GraphQLString),
                     },
                     resolve: async (_, args, __, info) => {
-                        const service = new ActivityService({
+                        const commentsService = new CommentsService({
                             accountability: this.accountability,
                             schema: this.schema,
+                            serviceOrigin: 'activity',
                         });
-                        const primaryKey = await service.updateOne(args['id'], { comment: args['comment'] });
+                        const primaryKey = await commentsService.updateOne(args['id'], { comment: args['comment'] });
                         if ('directus_activity' in ReadCollectionTypes) {
                             const selections = this.replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
                             const query = this.getQuery(args, selections || [], info.variableValues);
-                            return await service.readOne(primaryKey, query);
+                            return { ...(await commentsService.readOne(primaryKey, query)), id: args['id'] };
                         }
                         return true;
                     },
@@ -2825,11 +2825,12 @@ export class GraphQLService {
                         id: new GraphQLNonNull(GraphQLID),
                     },
                     resolve: async (_, args) => {
-                        const service = new ActivityService({
+                        const commentsService = new CommentsService({
                             accountability: this.accountability,
                             schema: this.schema,
+                            serviceOrigin: 'activity',
                         });
-                        await service.deleteOne(args['id']);
+                        await commentsService.deleteOne(args['id']);
                         return { id: args['id'] };
                     },
                 },

package/dist/services/index.d.ts

@@ -3,6 +3,7 @@ export * from './activity.js';
 export * from './assets.js';
 export * from './authentication.js';
 export * from './collections.js';
+export * from './comments.js';
 export * from './dashboards.js';
 export * from './extensions.js';
 export * from './fields.js';

package/dist/services/index.js

@@ -3,6 +3,7 @@ export * from './activity.js';
 export * from './assets.js';
 export * from './authentication.js';
 export * from './collections.js';
+export * from './comments.js';
 export * from './dashboards.js';
 export * from './extensions.js';
 export * from './fields.js';

package/dist/services/items.js

@@ -543,6 +543,7 @@ export class ItemsService {
                 action: 'update',
                 collection: this.collection,
                 primaryKeys: keys,
+                fields: Object.keys(payloadAfterHooks),
             }, {
                 schema: this.schema,
                 knex: this.knex,
@@ -706,7 +707,8 @@ export class ItemsService {
                 .where({ [primaryKeyField]: primaryKey })
                 .first());
         if (exists) {
-            return await this.updateOne(primaryKey, payload, opts);
+            const { [primaryKeyField]: _, ...data } = payload;
+            return await this.updateOne(primaryKey, data, opts);
         }
         else {
             return await this.createOne(payload, opts);

package/dist/services/mail/index.d.ts

@@ -2,7 +2,8 @@ import type { Accountability, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { SendMailOptions, Transporter } from 'nodemailer';
 import type { AbstractServiceOptions } from '../../types/index.js';
-export type EmailOptions = SendMailOptions & {
+export type EmailOptions = Omit<SendMailOptions, 'from'> & {
+    from?: string;
     template?: {
         name: string;
         data: Record<string, any>;

package/dist/services/mail/index.js

@@ -42,7 +42,10 @@ export class MailService {
         const { template, ...emailOptions } = payload;
         let { html } = options;
         const defaultTemplateData = await this.getDefaultTemplateData();
-        const from = `${defaultTemplateData.projectName} <${options.from || env['EMAIL_FROM']}>`;
+        const from = {
+            name: defaultTemplateData.projectName,
+            address: options.from || env['EMAIL_FROM'],
+        };
         if (template) {
             let templateData = template.data;
             templateData = {

package/dist/services/payload.js

@@ -3,7 +3,7 @@ import { parseJSON, toArray } from '@directus/utils';
 import { format, isValid, parseISO } from 'date-fns';
 import { unflatten } from 'flat';
 import Joi from 'joi';
-import { clone, cloneDeep, isNil, isObject, isPlainObject, omit, pick } from 'lodash-es';
+import { clone, cloneDeep, isNil, isObject, isPlainObject, pick } from 'lodash-es';
 import { randomUUID } from 'node:crypto';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
@@ -347,22 +347,22 @@ export class PayloadService {
                 knex: this.knex,
                 schema: this.schema,
             });
-            const relatedPrimary = this.schema.collections[relatedCollection].primary;
+            const relatedPrimaryKeyField = this.schema.collections[relatedCollection].primary;
             const relatedRecord = payload[relation.field];
             if (['string', 'number'].includes(typeof relatedRecord))
                 continue;
-            const hasPrimaryKey = relatedPrimary in relatedRecord;
-            let relatedPrimaryKey = relatedRecord[relatedPrimary];
+            const hasPrimaryKey = relatedPrimaryKeyField in relatedRecord;
+            let relatedPrimaryKey = relatedRecord[relatedPrimaryKeyField];
             const exists = hasPrimaryKey &&
                 !!(await this.knex
-                    .select(relatedPrimary)
+                    .select(relatedPrimaryKeyField)
                     .from(relatedCollection)
-                    .where({ [relatedPrimary]: relatedPrimaryKey })
+                    .where({ [relatedPrimaryKeyField]: relatedPrimaryKey })
                     .first());
             if (exists) {
-                const fieldsToUpdate = omit(relatedRecord, relatedPrimary);
-                if (Object.keys(fieldsToUpdate).length > 0) {
-                    await service.updateOne(relatedPrimaryKey, relatedRecord, {
+                const { [relatedPrimaryKeyField]: _, ...record } = relatedRecord;
+                if (Object.keys(record).length > 0) {
+                    await service.updateOne(relatedPrimaryKey, record, {
                         onRevisionCreate: (pk) => revisions.push(pk),
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
@@ -425,9 +425,9 @@ export class PayloadService {
                     .where({ [relatedPrimaryKeyField]: relatedPrimaryKey })
                     .first());
             if (exists) {
-                const fieldsToUpdate = omit(relatedRecord, relatedPrimaryKeyField);
-                if (Object.keys(fieldsToUpdate).length > 0) {
-                    await service.updateOne(relatedPrimaryKey, relatedRecord, {
+                const { [relatedPrimaryKeyField]: _, ...record } = relatedRecord;
+                if (Object.keys(record).length > 0) {
+                    await service.updateOne(relatedPrimaryKey, record, {
                         onRevisionCreate: (pk) => revisions.push(pk),
                         onRequireUserIntegrityCheck: (flags) => (userIntegrityCheckFlags |= flags),
                         bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
@@ -610,8 +610,9 @@ export class PayloadService {
                 if (alterations.update) {
                     const primaryKeyField = this.schema.collections[relation.collection].primary;
                     for (const item of alterations.update) {
-                        await service.updateOne(item[primaryKeyField], {
-                            ...item,
+                        const { [primaryKeyField]: key, ...record } = item;
+                        await service.updateOne(key, {
+                            ...record,
                             [relation.field]: parent || payload[currentPrimaryKeyField],
                         }, {
                             onRevisionCreate: (pk) => revisions.push(pk),

package/dist/services/users.js

@@ -260,6 +260,7 @@ export class UsersService extends ItemsService {
             }
         }
         // Manual constraint, see https://github.com/directus/directus/pull/19912
+        await this.knex('directus_comments').update({ user_updated: null }).whereIn('user_updated', keys);
         await this.knex('directus_notifications').update({ sender: null }).whereIn('sender', keys);
         await this.knex('directus_versions').update({ user_updated: null }).whereIn('user_updated', keys);
         await super.deleteMany(keys, opts);

package/dist/services/versions.js

@@ -1,10 +1,9 @@
 import { Action } from '@directus/constants';
-import { InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
+import { ForbiddenError, InvalidPayloadError, UnprocessableContentError } from '@directus/errors';
 import Joi from 'joi';
 import { assign, pick } from 'lodash-es';
 import objectHash from 'object-hash';
 import { getCache } from '../cache.js';
-import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
@@ -17,19 +16,36 @@ export class VersionsService extends ItemsService {
         super('directus_versions', options);
     }
     async validateCreateData(data) {
-        if (!data['key'])
-            throw new InvalidPayloadError({ reason: `"key" is required` });
+        const versionCreateSchema = Joi.object({
+            key: Joi.string().required(),
+            name: Joi.string().allow(null),
+            collection: Joi.string().required(),
+            item: Joi.string().required(),
+        });
+        const { error } = versionCreateSchema.validate(data);
+        if (error)
+            throw new InvalidPayloadError({ reason: error.message });
         // Reserves the "main" version key for the version query parameter
         if (data['key'] === 'main')
             throw new InvalidPayloadError({ reason: `"main" is a reserved version key` });
-        if (!data['collection']) {
-            throw new InvalidPayloadError({ reason: `"collection" is required` });
+        if (this.accountability) {
+            try {
+                await validateAccess({
+                    accountability: this.accountability,
+                    action: 'read',
+                    collection: data['collection'],
+                    primaryKeys: [data['item']],
+                }, {
+                    schema: this.schema,
+                    knex: this.knex,
+                });
+            }
+            catch {
+                throw new ForbiddenError();
+            }
         }
-        if (!data['item'])
-            throw new InvalidPayloadError({ reason: `"item" is required` });
         const { CollectionsService } = await import('./collections.js');
         const collectionsService = new CollectionsService({
-            accountability: null,
             knex: this.knex,
             schema: this.schema,
         });
@@ -39,7 +55,11 @@ export class VersionsService extends ItemsService {
                 reason: `Content Versioning is not enabled for collection "${data['collection']}"`,
             });
         }
-        const existingVersions = await super.readByQuery({
+        const sudoService = new VersionsService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const existingVersions = await sudoService.readByQuery({
             aggregate: { count: ['*'] },
             filter: { key: { _eq: data['key'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
         });
@@ -48,32 +68,8 @@ export class VersionsService extends ItemsService {
                 reason: `Version "${data['key']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
             });
         }
-        // will throw an error if the accountability does not have permission to read the item
-        if (this.accountability) {
-            await validateAccess({
-                accountability: this.accountability,
-                action: 'read',
-                collection: data['collection'],
-                primaryKeys: [data['item']],
-            }, {
-                schema: this.schema,
-                knex: this.knex,
-            });
-        }
     }
     async getMainItem(collection, item, query) {
-        // will throw an error if the accountability does not have permission to read the item
-        if (this.accountability) {
-            await validateAccess({
-                accountability: this.accountability,
-                action: 'read',
-                collection,
-                primaryKeys: [item],
-            }, {
-                schema: this.schema,
-                knex: this.knex,
-            });
-        }
         const itemsService = new ItemsService(collection, {
             knex: this.knex,
             accountability: this.accountability,
@@ -96,6 +92,7 @@ export class VersionsService extends ItemsService {
         });
         return result.map((revision) => revision['delta']);
     }
+    // TODO: Remove legacy need to return a version array in subsequent release
     async getVersionSaves(key, collection, item) {
         const filter = {
             key: { _eq: key },
@@ -107,6 +104,9 @@ export class VersionsService extends ItemsService {
         const versions = await this.readByQuery({ filter });
         if (!versions?.[0])
             return null;
+        if (versions[0]['delta']) {
+            return [versions[0]['delta']];
+        }
         const saves = await this.getVersionSavesById(versions[0]['id']);
         return saves;
     }
@@ -122,7 +122,6 @@ export class VersionsService extends ItemsService {
         }
         const keyCombos = new Set();
         for (const item of data) {
-            await this.validateCreateData(item);
             const keyCombo = `${item['key']}-${item['collection']}-${item['item']}`;
             if (keyCombos.has(keyCombo)) {
                 throw new UnprocessableContentError({
@@ -130,8 +129,6 @@ export class VersionsService extends ItemsService {
                 });
             }
             keyCombos.add(keyCombo);
-            const mainItem = await this.getMainItem(item['collection'], item['item']);
-            item['hash'] = objectHash(mainItem);
         }
         return super.createMany(data, opts);
     }
@@ -139,7 +136,7 @@ export class VersionsService extends ItemsService {
         // Only allow updates on "key" and "name" fields
         const versionUpdateSchema = Joi.object({
             key: Joi.string(),
-            name: Joi.string().allow(null).optional(),
+            name: Joi.string().allow(null),
         });
         const { error } = versionUpdateSchema.validate(data);
         if (error)
@@ -205,14 +202,25 @@ export class VersionsService extends ItemsService {
             data: revisionDelta,
             delta: revisionDelta,
         });
+        let existingDelta = version['delta'];
+        if (!existingDelta) {
+            const saves = await this.getVersionSavesById(key);
+            existingDelta = assign({}, ...saves);
+        }
+        const finalVersionDelta = assign({}, existingDelta, revisionDelta ? JSON.parse(revisionDelta) : null);
+        const sudoService = new ItemsService(this.collection, {
+            knex: this.knex,
+            schema: this.schema,
+        });
+        await sudoService.updateOne(key, { delta: finalVersionDelta });
         const { cache } = getCache();
         if (shouldClearCache(cache, undefined, collection)) {
             cache.clear();
         }
-        return data;
+        return finalVersionDelta;
     }
     async promote(version, mainHash, fields) {
-        const { id, collection, item } = (await this.readOne(version));
+        const { id, collection, item, delta } = (await this.readOne(version));
         // will throw an error if the accountability does not have permission to update the item
         if (this.accountability) {
             await validateAccess({
@@ -231,11 +239,18 @@ export class VersionsService extends ItemsService {
                 reason: `Main item has changed since this version was last updated`,
             });
         }
-        const saves = await this.getVersionSavesById(id);
-        const versionResult = assign({}, ...saves);
+        let versionResult;
+        if (delta) {
+            versionResult = delta;
+        }
+        else {
+            const saves = await this.getVersionSavesById(id);
+            versionResult = assign({}, ...saves);
+        }
         const payloadToUpdate = fields ? pick(versionResult, fields) : versionResult;
         const itemsService = new ItemsService(collection, {
             accountability: this.accountability,
+            knex: this.knex,
             schema: this.schema,
         });
         const payloadAfterHooks = await emitter.emitFilter(['items.promote', `${collection}.items.promote`], payloadToUpdate, {
@@ -243,7 +258,7 @@ export class VersionsService extends ItemsService {
             item,
             version,
         }, {
-            database: getDatabase(),
+            database: this.knex,
             schema: this.schema,
             accountability: this.accountability,
         });
@@ -254,7 +269,7 @@ export class VersionsService extends ItemsService {
             item: updatedItemKey,
             version,
         }, {
-            database: getDatabase(),
+            database: this.knex,
             schema: this.schema,
             accountability: this.accountability,
         });

package/dist/utils/apply-diff.js

@@ -26,7 +26,6 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
     await transaction(database, async (trx) => {
         const collectionsService = new 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 === DiffKind.NEW && diff[0].rhs) {
@@ -82,7 +81,6 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
                         // 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);
                     }
@@ -122,13 +120,14 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
         // 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 }) => {
+        const collectionsToDelete = snapshotDiff.collections.filter(({ diff }) => {
             if (diff.length === 0 || diff[0] === undefined)
                 return false;
             const collectionDiff = diff[0];
-            return collectionDiff.kind === DiffKind.DELETE && collectionDiff.lhs?.meta?.group === null;
-        }));
+            return collectionDiff.kind === DiffKind.DELETE;
+        });
+        if (collectionsToDelete.length > 0)
+            await deleteCollections(collectionsToDelete);
         for (const { collection, diff } of snapshotDiff.collections) {
             if (diff?.[0]?.kind === DiffKind.EDIT || diff?.[0]?.kind === DiffKind.ARRAY) {
                 const currentCollection = currentSnapshot.collections.find((field) => {

package/dist/utils/get-service.js

@@ -1,5 +1,5 @@
 import { ForbiddenError } from '@directus/errors';
-import { AccessService, ActivityService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PoliciesService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, TranslationsService, UsersService, VersionsService, WebhooksService, } from '../services/index.js';
+import { AccessService, ActivityService, CommentsService, DashboardsService, FilesService, FlowsService, FoldersService, ItemsService, NotificationsService, OperationsService, PanelsService, PermissionsService, PoliciesService, PresetsService, RevisionsService, RolesService, SettingsService, SharesService, TranslationsService, UsersService, VersionsService, WebhooksService, } from '../services/index.js';
 /**
  * Select the correct service for the given collection. This allows the individual services to run
  * their custom checks (f.e. it allows `UsersService` to prevent updating TFA secret from outside).
@@ -10,6 +10,8 @@ export function getService(collection, opts) {
             return new AccessService(opts);
         case 'directus_activity':
             return new ActivityService(opts);
+        case 'directus_comments':
+            return new CommentsService({ ...opts, serviceOrigin: 'comments' });
         case 'directus_dashboards':
             return new DashboardsService(opts);
         case 'directus_files':

package/dist/utils/sanitize-schema.d.ts

@@ -16,7 +16,7 @@ export declare function sanitizeCollection(collection: Collection | undefined):
  * @returns sanitized field
  */
 export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
-export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "data_type" | "default_value" | "max_length" | "numeric_scale" | "is_nullable" | "is_unique" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
+export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "data_type" | "default_value" | "max_length" | "numeric_scale" | "is_nullable" | "is_unique" | "is_indexed" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
 /**
  * Pick certain database vendor specific relation properties that should be compared when performing diff
  *

package/dist/utils/sanitize-schema.js

@@ -34,6 +34,7 @@ export function sanitizeField(field, sanitizeAllSchema = false) {
             'schema.numeric_scale',
             'schema.is_nullable',
             'schema.is_unique',
+            'schema.is_indexed',
             'schema.is_primary_key',
             'schema.is_generated',
             'schema.generation_expression',
@@ -54,6 +55,7 @@ export function sanitizeColumn(column) {
         'numeric_scale',
         'is_nullable',
         'is_unique',
+        'is_indexed',
         'is_primary_key',
         'is_generated',
         'generation_expression',