contentful-migration 4.9.3 → 4.9.5

package/built/lib/intent-validator/field-movement.d.ts

@@ -0,0 +1,21 @@
+import FieldMoveIntent from '../intent/field-move';
+import * as Joi from 'joi';
+import IntentValidator from '../interfaces/intent-validator';
+import ValidationError from '../interfaces/errors';
+declare class FieldMovementStepValidator implements IntentValidator {
+    appliesTo(step: any): any;
+    get validationErrors(): {
+        INVALID_MOVEMENT_TYPE: (typeName: any) => string;
+        INVALID_MOVEMENT_WITH_SELF: (fieldId: any) => string;
+        INVALID_MOVEMENT_NAME: (movement: any) => string;
+        INVALID_MOVEMENT_NAME_WITH_SUGGESTION: (movement: any, suggestion: any) => string;
+    };
+    get schema(): {
+        toTheTop: Joi.AnySchema<any>;
+        toTheBottom: Joi.AnySchema<any>;
+        afterField: Joi.StringSchema;
+        beforeField: Joi.StringSchema;
+    };
+    validate(intent: FieldMoveIntent): ValidationError[];
+}
+export default FieldMovementStepValidator;

package/built/lib/intent-validator/field-update.d.ts

@@ -0,0 +1,23 @@
+import SchemaValidator from './schema-validator';
+import * as Joi from 'joi';
+declare class FieldUpdateStepValidator extends SchemaValidator {
+    protected article: string;
+    protected displayName: string;
+    appliesTo(step: any): any;
+    get schema(): {
+        id: Joi.StringSchema;
+        newId: Joi.StringSchema;
+        name: Joi.StringSchema;
+        type: Joi.StringSchema;
+        localized: Joi.BooleanSchema;
+        required: Joi.BooleanSchema;
+        validations: Joi.ArraySchema;
+        defaultValue: Joi.ObjectSchema<any>;
+        disabled: Joi.BooleanSchema;
+        omitted: Joi.BooleanSchema;
+        deleted: Joi.BooleanSchema;
+        linkType: Joi.StringSchema;
+        items: Joi.ObjectSchema<any>;
+    };
+}
+export default FieldUpdateStepValidator;

package/built/lib/intent-validator/schema-validator.d.ts

@@ -0,0 +1,19 @@
+import IntentValidator from '../interfaces/intent-validator';
+import ValidationError from '../interfaces/errors';
+import Intent from '../interfaces/intent';
+import Joi from 'joi';
+declare abstract class SchemaValidator implements IntentValidator {
+    protected abstract displayName: string;
+    protected abstract article: string;
+    get validationErrors(): {
+        INVALID_PROPERTY_NAME: (propName: any, article: any, typeName: any) => string;
+        INVALID_PROPERTY_NAME_WITH_SUGGESTION: (propName: any, article: any, typeName: any, suggestion: any) => string;
+        INVALID_PROPERTY_TYPE: (propName: any, typeName: any, actualType: any, expectedType: any) => string;
+        INVALID_VALUE_IN_ALTERNATIVES: (propName: any, typeName: any, value: any, expectedTypes: any) => string;
+    };
+    abstract appliesTo(intent: Intent): boolean;
+    get propertyNameToValidate(): string;
+    get schema(): Record<string, Joi.Schema>;
+    validate(intent: Intent): ValidationError[];
+}
+export default SchemaValidator;

package/built/lib/intent-validator/tag-update.d.ts

@@ -0,0 +1,11 @@
+import SchemaValidator from './schema-validator';
+import * as Joi from 'joi';
+declare class TagUpdateStepValidator extends SchemaValidator {
+    protected article: string;
+    protected displayName: string;
+    appliesTo(step: any): any;
+    get schema(): {
+        name: Joi.StringSchema;
+    };
+}
+export default TagUpdateStepValidator;

package/built/lib/interfaces/annotation.d.ts

@@ -0,0 +1,41 @@
+import { PayloadValidationError } from './errors';
+declare type AnnotationTarget = {
+    type: string;
+    accept?: Record<string, any>[];
+};
+declare type AssignmentTarget = {
+    type: string;
+    data: Record<string, any>;
+};
+export declare type AnnotationAssignment = {
+    annotationId: string;
+    target: AssignmentTarget;
+};
+export declare type AnnotationData = {
+    id: string;
+    targets: AnnotationTarget[];
+};
+export declare class Annotation {
+    private annotationData;
+    constructor(annotationData: AnnotationData);
+    static isValidId(id: string): id is AnnotationId;
+    /**
+     * Verifies if given assignment complies with the annotation definition
+     */
+    validateAssignment(assignment: AnnotationAssignment): PayloadValidationError | undefined;
+}
+export declare const availableAnnotations: {
+    'Contentful:AggregateRoot': Annotation;
+    'Contentful:ManagedByEnvironmentTemplate': Annotation;
+    'Contentful:AggregateComponent': Annotation;
+};
+export declare type AnnotationId = keyof typeof availableAnnotations;
+export declare function validateAnnotationAssignment(assignment: AnnotationAssignment): PayloadValidationError | undefined;
+export declare type AnnotationLink = {
+    sys: {
+        type: 'Link';
+        linkType: 'Annotation';
+        id: AnnotationId;
+    };
+};
+export {};

package/built/lib/interfaces/api-entry.d.ts

@@ -0,0 +1,19 @@
+import APITagLink from './api-tag-link';
+export default interface APIEntry {
+    sys: {
+        id: string;
+        version: number;
+        publishedVersion?: number;
+        contentType: {
+            sys: {
+                type: string;
+                linkType: string;
+                id: string;
+            };
+        };
+    };
+    fields: object;
+    metadata?: {
+        tags: APITagLink[];
+    };
+}

package/built/lib/interfaces/api-fetcher.d.ts

@@ -0,0 +1,10 @@
+import IntentList from '../intent-list/index';
+import { ContentType } from '../entities/content-type';
+export default interface APIFetcher {
+    getEntriesInIntents(intentList: IntentList): any;
+    getContentTypesInChunks(intentList: IntentList): any;
+    getEditorInterfacesInIntents(intentList: IntentList): any;
+    getLocalesForSpace(): any;
+    checkContentTypesForDeletedCts(intentList: IntentList, contentTypes: ContentType[]): any;
+    getTagsForEnvironment(intentList: IntentList): any;
+}

package/built/lib/interfaces/api-tag-link.d.ts

@@ -0,0 +1,7 @@
+export default interface APITagLink {
+    sys: {
+        id: string;
+        type: 'Link';
+        linkType: 'Tag';
+    };
+}

package/built/lib/interfaces/api-tag.d.ts

@@ -0,0 +1,9 @@
+export declare type TagVisibility = 'private' | 'public';
+export default interface APITag {
+    sys: {
+        id: string;
+        version: number;
+        visibility: TagVisibility;
+    };
+    name: string;
+}

package/built/lib/interfaces/content-transform.d.ts

@@ -0,0 +1,6 @@
+export default interface ContentTransform {
+    from: string[];
+    to: string[];
+    shouldPublish?: boolean | 'preserve';
+    transformEntryForLocale(inputFields: any, locale: string): any;
+}

package/built/lib/interfaces/content-type.d.ts

@@ -0,0 +1,95 @@
+import { AnnotationLink } from './annotation';
+interface Field {
+    id: string;
+    newId?: string;
+    name?: string;
+    type?: string;
+    linkType?: string;
+    items?: {
+        type: string;
+        linkType?: string;
+        validations?: any[];
+    };
+    omitted?: boolean;
+    deleted?: boolean;
+    localized?: boolean;
+    required?: boolean;
+    validations?: any[];
+    disabled?: boolean;
+    defaultValue?: {
+        [locale: string]: any;
+    };
+}
+declare type ContentTypeMetadata = {
+    annotations?: {
+        ContentType?: AnnotationLink[];
+        ContentTypeField?: Record<string, AnnotationLink[]>;
+    };
+};
+interface APIContentType {
+    sys: {
+        id: string;
+        version: number;
+    };
+    fields: Field[];
+    name: string;
+    description?: string;
+    displayField?: string;
+    metadata?: ContentTypeMetadata;
+}
+declare type APIParameterValue = number | boolean | string;
+interface APIEditorInterfaceSettings {
+    [setting: string]: APIParameterValue;
+}
+declare type APISidebarWidgetNamespace = 'sidebar-builtin' | 'extension' | 'app';
+declare type APIControlWidgetNamespace = 'builtin' | 'extension' | 'app';
+interface APIEditorInterfaceControl {
+    fieldId: string;
+    widgetId?: string;
+    widgetNamespace?: APIControlWidgetNamespace;
+    settings?: APIEditorInterfaceSettings;
+}
+interface APIEditorInterfaceGroupControl {
+    groupId: string;
+    widgetId?: string;
+    widgetNamespace?: string;
+    settings?: APIEditorInterfaceSettings;
+}
+interface APISidebarWidgetSettings {
+    [key: string]: APIParameterValue;
+}
+interface APIEditorInterfaceSidebar {
+    widgetId: string;
+    widgetNamespace: APISidebarWidgetNamespace;
+    disabled?: boolean;
+    settings?: APISidebarWidgetSettings;
+}
+interface APIEditorIntefaceEditor {
+    widgetId: string;
+    widgetNamespace: APIControlWidgetNamespace;
+    settings?: {
+        [key: string]: APIParameterValue;
+    };
+}
+interface APIEditorLayoutFieldGroupItem {
+    groupId: string;
+    name?: string;
+    items: APIEditorLayoutItem[];
+}
+interface APIEditorLayoutFieldItem {
+    fieldId: string;
+}
+declare type APIEditorLayoutItem = APIEditorLayoutFieldItem | APIEditorLayoutFieldGroupItem;
+declare type APIEditorInterfaceEditorLayout = APIEditorLayoutFieldGroupItem[];
+interface APIEditorInterfaces {
+    sys: {
+        version: number;
+    };
+    controls: APIEditorInterfaceControl[];
+    sidebar?: APIEditorInterfaceSidebar[];
+    editor?: APIEditorIntefaceEditor;
+    editors?: APIEditorIntefaceEditor[];
+    editorLayout?: APIEditorInterfaceEditorLayout;
+    groupControls?: APIEditorInterfaceGroupControl[];
+}
+export { APIContentType as default, APIContentType, Field, APIEditorInterfaces, APIEditorInterfaceControl, APIEditorInterfaceGroupControl, APIEditorInterfaceSettings, APIEditorInterfaceSidebar, APIEditorIntefaceEditor, APIEditorInterfaceEditorLayout, APIEditorLayoutFieldGroupItem, APISidebarWidgetSettings, APIControlWidgetNamespace, APISidebarWidgetNamespace, ContentTypeMetadata };

package/built/lib/interfaces/entry-derive.d.ts

@@ -0,0 +1,9 @@
+export default interface EntryDerive {
+    derivedContentType: string;
+    from: string[];
+    toReferenceField: string;
+    derivedFields: string[];
+    identityKey: (fromFields: any) => Promise<string>;
+    shouldPublish?: boolean | 'preserve';
+    deriveEntryForLocale(inputFields: any, locale: string): Promise<any>;
+}

package/built/lib/interfaces/entry-set-tags.d.ts

@@ -0,0 +1,6 @@
+import APITagLink from './api-tag-link';
+export default interface EntrySetTags {
+    contentType: string;
+    from: string[];
+    setTagsForEntry(inputFields: any, entryTags: APITagLink[], apiTags: APITagLink[]): any;
+}

package/built/lib/interfaces/entry-transform-to-type.d.ts

@@ -0,0 +1,10 @@
+export default interface TransformEntryToType {
+    sourceContentType: string;
+    targetContentType: string;
+    from?: string[];
+    identityKey: (fromFields: any) => Promise<string>;
+    shouldPublish?: boolean | 'preserve';
+    removeOldEntries?: boolean;
+    updateReferences?: boolean;
+    transformEntryForLocale(inputFields: any, locale: string): Promise<any>;
+}

package/built/lib/interfaces/errors.d.ts

@@ -0,0 +1,35 @@
+import { Intent } from './intent';
+interface ValidationError {
+    type: string;
+    message: string;
+    details?: {
+        intent: Intent;
+    };
+}
+interface PayloadValidationError extends ValidationError {
+    type: 'InvalidPayload';
+    message: string;
+}
+interface InvalidActionError extends ValidationError {
+    type: 'InvalidAction';
+    message: string;
+}
+interface InvalidTypeError extends ValidationError {
+    type: 'InvalidType';
+    message: string;
+    details: {
+        intent: Intent;
+    };
+}
+interface InvalidMovementError extends ValidationError {
+    type: 'InvalidMovement';
+    message: string;
+    details: {
+        intent: Intent;
+    };
+}
+interface InvalidPropertyError extends ValidationError {
+    type: 'InvalidProperty';
+    message: string;
+}
+export { ValidationError as default, PayloadValidationError, InvalidActionError, InvalidTypeError, InvalidMovementError, InvalidPropertyError };

package/built/lib/interfaces/intent-validator.d.ts

@@ -0,0 +1,6 @@
+import ValidationError from './errors';
+import Intent from './intent';
+export default interface IntentValidator {
+    appliesTo(intent: Intent): boolean;
+    validate(intent: Intent): ValidationError[];
+}

package/built/lib/interfaces/intent.d.ts

@@ -0,0 +1,60 @@
+import { APIAction, EntityAction } from '../action/action';
+import RawStep from './raw-step';
+import { PlanMessage } from './plan-message';
+interface Intent {
+    toActions(): (APIAction | EntityAction)[];
+    toRaw(): RawStep;
+    getContentTypeId(): string;
+    getRelatedContentTypeIds(): string[];
+    getFieldId(): string;
+    getInvalidMethod(): string;
+    getFieldGroupId(): string;
+    getNewFieldGroupId(): string;
+    getFieldGroupProps(): {
+        [prop: string]: string;
+    };
+    getRawType(): string;
+    getTagId(): string;
+    requiresAllEntries(): boolean;
+    requiresAllTags(): boolean;
+    requiresContentType(): boolean;
+    shouldSave(): boolean;
+    shouldPublish(): boolean;
+    isContentTypeUpdate(): boolean;
+    isContentTypeDelete(): boolean;
+    isContentTypeCreate(): boolean;
+    isFieldCreate(): boolean;
+    isFieldUpdate(): boolean;
+    isFieldDelete(): boolean;
+    isFieldRename(): boolean;
+    isFieldMove(): boolean;
+    isAboutContentType(): boolean;
+    isAboutField(): boolean;
+    isAboutEditorLayout(): boolean;
+    isContentTransform(): boolean;
+    isEntryDerive(): boolean;
+    isEntryTransformToType(): boolean;
+    isGroupable(): boolean;
+    isEditorInterfaceIntent(): boolean;
+    isEditorInterfaceUpdate(): boolean;
+    isSidebarUpdate(): boolean;
+    isTagIntent(): boolean;
+    isTagCreate(): boolean;
+    isTagUpdate(): boolean;
+    isTagDelete(): boolean;
+    isEntrySetTags(): boolean;
+    isEditorLayoutCreate(): boolean;
+    isEditorLayoutDelete(): boolean;
+    isEditorLayoutUpdate(): boolean;
+    isEditorLayoutInvalidMethod(): boolean;
+    isFieldGroupCreate(): boolean;
+    isFieldGroupDelete(): boolean;
+    isFieldGroupUpdate(): boolean;
+    isFieldGroupIdChange(): boolean;
+    isFieldGroupControlChange(): boolean;
+    isComposedIntent(): boolean;
+    groupsWith(other: Intent): boolean;
+    endsGroup(): boolean;
+    toPlanMessage(): PlanMessage;
+}
+export { Intent as default, Intent };

package/built/lib/interfaces/plan-message.d.ts

@@ -0,0 +1,10 @@
+interface Section {
+    heading: string;
+    details: string[];
+}
+interface PlanMessage {
+    heading: string;
+    details: string[];
+    sections: Section[];
+}
+export { PlanMessage, Section };

package/built/lib/interfaces/raw-step.d.ts

@@ -0,0 +1,89 @@
+import { TagVisibility } from './api-tag';
+import ContentTransform from './content-transform';
+import EntryDerive from './entry-derive';
+import EntrySetTags from './entry-set-tags';
+import TransformEntryToType from './entry-transform-to-type';
+import { SidebarWidgetNamespace, SidebarWidgetSettings } from '../action/sidebarwidget';
+import { EntryEditorNamespace, EntryEditorSettings } from '../action/entryeditor-configure';
+import { EntryEditor } from '../action/entryeditors-configure';
+import { APIEditorInterfaceGroupControl, APIEditorLayoutFieldGroupItem } from './content-type';
+import { AnnotationId } from './annotation';
+interface RawStep {
+    type: string;
+    meta: RawStepMeta;
+    payload: RawStepPayload;
+}
+interface RawStepMeta {
+    contentTypeInstanceId?: string;
+    fieldInstanceId?: string;
+    fieldGroupInstanceId?: string;
+    tagInstanceId?: string;
+    callsite: CallSiteInfo;
+}
+interface CallSiteInfo {
+    line: number;
+    file: string;
+}
+interface RawStepPayload {
+    contentTypeId?: string;
+    fieldId?: string;
+    props?: RawStepProps;
+    transformation?: ContentTransform;
+    derivation?: EntryDerive;
+    movement?: Movement;
+    entryTransformationToType?: TransformEntryToType;
+    editorInterfaceCopy?: EditorInterfaceCopy;
+    editorInterfaceReset?: EditorInterfaceReset;
+    editorInterface?: EditorInterfaceInfo;
+    sidebarWidget?: SidebarWidgetInfo;
+    entryEditor?: EntryEditorInfo;
+    entryEditors?: EntryEditor[];
+    invalidMethod?: string;
+    fieldGroupId?: string;
+    newFieldGroupId?: string;
+    parentFieldGroupId?: string;
+    fieldGroupProps?: Omit<APIEditorLayoutFieldGroupItem, 'groupId' | 'items'>;
+    groupControl?: Omit<APIEditorInterfaceGroupControl, 'groupId'>;
+    tagId?: string;
+    tagVisibility?: TagVisibility;
+    entryTransformationForTags?: EntrySetTags;
+    annotations?: AnnotationId[];
+}
+interface EditorInterfaceInfo {
+    fieldId: string;
+    widgetId: string;
+    widgetNamespace: FieldControlNamespace;
+    settings?: FieldControlSettings;
+}
+declare type SettingsParameterValue = number | boolean | string;
+interface FieldControlSettings {
+    [setting: string]: SettingsParameterValue;
+}
+declare type FieldControlNamespace = 'builtin' | 'extension';
+interface Movement {
+    pivot?: string;
+    direction?: string;
+}
+interface EditorInterfaceCopy {
+    source?: string;
+    destination?: string;
+}
+interface EditorInterfaceReset {
+    fieldId: string;
+}
+interface RawStepProps {
+    [propName: string]: any;
+}
+export interface SidebarWidgetInfo {
+    widgetId: string;
+    widgetNamespace?: SidebarWidgetNamespace;
+    disabled?: boolean;
+    settings?: SidebarWidgetSettings;
+    insertBeforeWidgetId?: string;
+}
+export interface EntryEditorInfo {
+    widgetId: string;
+    widgetNamespace?: EntryEditorNamespace;
+    settings?: EntryEditorSettings;
+}
+export { RawStep as default, RawStep, RawStepMeta, CallSiteInfo, RawStepPayload, RawStepProps, EditorInterfaceInfo };

package/built/lib/interfaces/request.d.ts

@@ -0,0 +1,12 @@
+interface HttpRequest {
+    method: 'PUT' | 'POST' | 'DELETE' | 'GET';
+    url: string;
+    headers?: object;
+    data?: {
+        name?: string;
+        description?: string;
+        displayField?: string;
+        fields?: object;
+    };
+}
+export { HttpRequest as default, HttpRequest };

package/built/lib/migration-chunks/validation/content-type.d.ts

@@ -0,0 +1,4 @@
+import ContentType from '../../entities/content-type';
+import Intent from '../../interfaces/intent';
+import { InvalidActionError } from '../../interfaces/errors';
+export default function (intents: Intent[], contentTypes: ContentType[]): InvalidActionError[];

package/built/lib/migration-chunks/validation/duplicate-props.d.ts

@@ -0,0 +1,3 @@
+import IntentList from '../../intent-list';
+import ValidationError from '../../interfaces/errors';
+export default function (intentList: IntentList): ValidationError[];

package/built/lib/migration-chunks/validation/editor-layout.d.ts

@@ -0,0 +1,5 @@
+import Intent from '../../interfaces/intent';
+import { ContentType, EditorInterfaces } from '../../entities/content-type';
+import { InvalidActionError } from '../../interfaces/errors';
+import { FieldsContext } from './index';
+export default function (intents: Intent[], editorInterfaces: Map<string, EditorInterfaces>, fieldsContext: FieldsContext, contentTypes: ContentType[]): InvalidActionError[];

package/built/lib/migration-chunks/validation/errors.d.ts

@@ -0,0 +1,23 @@
+interface ErrorGroup {
+    [identifier: string]: (id?: any, ...args: any[]) => string;
+}
+interface ErrorCreators {
+    field: {
+        [groupIdentifier: string]: ErrorGroup;
+    };
+    contentType: {
+        [groupIdentifier: string]: ErrorGroup;
+    };
+    editorLayout: {
+        [groupIdentifier: string]: ErrorGroup;
+    };
+    entry: {
+        [groupIdentifier: string]: ErrorGroup;
+    };
+    tag: {
+        [groupIdentifier: string]: ErrorGroup;
+    };
+    generic: ErrorGroup;
+}
+declare const errorCreators: ErrorCreators;
+export default errorCreators;

package/built/lib/migration-chunks/validation/field.d.ts

@@ -0,0 +1,8 @@
+import ValidationError from '../../interfaces/errors';
+import { Intent } from '../../interfaces/intent';
+import { ContentType } from '../../entities/content-type';
+import { FieldsContext } from './index';
+export default function (intents: Intent[], contentTypes?: ContentType[]): {
+    errors: ValidationError[];
+    fieldsContext: FieldsContext;
+};

package/built/lib/migration-chunks/validation/index.d.ts

@@ -0,0 +1,19 @@
+import IntentList from '../../intent-list';
+import { ContentType, EditorInterfaces } from '../../entities/content-type';
+import { Tag } from '../../entities/tag';
+import ValidationError, { InvalidActionError } from '../../interfaces/errors';
+export declare type FieldsContext = {
+    contentTypeFields: Record<string, Set<string>>;
+    recentlyRemoved: Record<string, Set<string>>;
+    recentlyMoved: Record<string, Set<string>>;
+    changedFieldIds: Record<string, Map<string, string>>;
+};
+export declare const invalidActionError: (message: any, intent: any) => {
+    type: string;
+    message: any;
+    details: {
+        intent: any;
+    };
+};
+declare function validateIntents(intentList: IntentList, contentTypes: ContentType[], editorInterfaces: Map<string, EditorInterfaces>, tags: Tag[]): ValidationError[] | InvalidActionError[];
+export { validateIntents as default, validateIntents };

package/built/lib/migration-chunks/validation/tag.d.ts

@@ -0,0 +1,4 @@
+import Tag from '../../entities/tag';
+import Intent from '../../interfaces/intent';
+import { InvalidActionError } from '../../interfaces/errors';
+export default function (intents: Intent[], tags: Tag[]): InvalidActionError[];

package/built/lib/migration-parser.d.ts

@@ -0,0 +1,16 @@
+import { RequestBatch } from './offline-api';
+import ValidationError, { InvalidActionError } from './interfaces/errors';
+import { ClientConfig } from '../bin/lib/config';
+declare class ParseResult {
+    batches: RequestBatch[];
+    stepsValidationErrors: ValidationError[];
+    payloadValidationErrors: InvalidActionError[] | ValidationError[];
+    hasValidationErrors(): boolean;
+    hasRuntimeErrors(): boolean;
+    hasStepsValidationErrors(): boolean;
+    hasPayloadValidationErrors(): boolean;
+    getRuntimeErrors(): any[];
+    getValidationErrors(): any[];
+}
+declare const createMigrationParser: (makeRequest: Function, config: ClientConfig) => (migrationCreator: (migration: any) => any) => Promise<ParseResult>;
+export { createMigrationParser as default, createMigrationParser, ParseResult };