@stackbit/cms-core 0.1.3 → 0.1.4-alpha.1

package/src/index.ts

@@ -1,11 +1,12 @@
 export * as stackbit from './stackbit';
 export * as annotator from './annotator';
 export * as utils from './utils';
+export * as searchUtils from './utils/search-utils';
 export * as consts from './consts';
 export * from './common/common-schema';
 export * from './common/common-types';
 export * from './content-store';
-export * as ContentSourceTypes from './content-source-interface';
 export * as ContentStoreTypes from './content-store-types';
 export { default as encodeData } from './encoder';
-export * from './encoder';
+export * from './encoder';
+export * from './types/search-filter';

package/src/types/search-filter.ts

@@ -0,0 +1,53 @@
+type Distribute<U> = U extends any ? U[] : never;
+
+type ValueType = string | number | Date | boolean;
+
+type BaseFilterItem = {
+  field: string;
+  isMeta?: boolean;
+};
+
+type EqualFilterItem = BaseFilterItem & {
+  operator: 'eq' | 'neq';
+  value: ValueType;
+};
+
+type UndefinedFilterItem = BaseFilterItem & {
+  operator: 'is-undefined' | 'is-not-undefined';
+}
+
+type CompareFilterItem = BaseFilterItem & {
+  operator: 'gte' | 'lte';
+  value: ValueType;
+};
+
+type IncludeStringFilterItem = BaseFilterItem & {
+  operator: 'includes' | 'not-includes';
+  value: string;
+};
+
+type IncludeListFilterItem = BaseFilterItem & {
+  operator: 'in' | 'nin';
+  values: Distribute<ValueType>;
+};
+
+type IncludeAllFilterItem = BaseFilterItem & {
+  operator: 'all';
+  values: Distribute<ValueType>;
+};
+
+type BetweenFilterItem = BaseFilterItem & {
+  operator: 'between';
+  startValue: ValueType;
+  endValue: ValueType;
+};
+
+export type SearchFilterItem = EqualFilterItem | UndefinedFilterItem | CompareFilterItem | IncludeStringFilterItem | IncludeListFilterItem | IncludeAllFilterItem | BetweenFilterItem;
+
+export type SearchFilter = LogicalOperator;
+
+type LogicalOperator = LogicalAndOperator;
+
+type LogicalAndOperator = {
+  'and': SearchFilterItem[];
+};

package/src/utils/create-update-csi-docs.ts

@@ -0,0 +1,457 @@
+import _ from 'lodash';
+import slugify from 'slugify';
+
+import { Model } from '@stackbit/sdk';
+import { Model as CSIModel, Field, FieldObjectProps, FieldSpecificProps, UpdateOperationListFieldItem } from '@stackbit/types';
+import { mapPromise } from '@stackbit/utils';
+import * as CSITypes from '@stackbit/types';
+
+import * as ContentStoreTypes from '../content-store-types';
+
+export type CreateDocumentCallback = ({
+    updateOperationFields,
+    modelName
+}: {
+    updateOperationFields: Record<string, CSITypes.UpdateOperationField>;
+    modelName: string;
+}) => Promise<CSITypes.Document>;
+
+export function getCreateDocumentThunk({
+    csiModelMap,
+    locale,
+    userContext,
+    contentSourceInstance
+}: {
+    csiModelMap: Record<string, CSIModel>;
+    locale?: string;
+    userContext: unknown;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): CreateDocumentCallback {
+    return async ({ updateOperationFields, modelName }) => {
+        // When passing model and modelMap to contentSourceInstance, we have to pass
+        // the original models (i.e., csiModel and csiModelMap) that we've received
+        // from that contentSourceInstance. We can't pass internal models as they
+        // might
+        const csiModel = csiModelMap[modelName];
+        if (!csiModel) {
+            throw new Error(`no model with name '${modelName}' was found`);
+        }
+        return await contentSourceInstance.createDocument({
+            updateOperationFields: updateOperationFields,
+            model: csiModel,
+            modelMap: csiModelMap,
+            locale,
+            userContext
+        });
+    };
+}
+
+/**
+ * Receives a plain `object`, and creates a map of `CSITypes.UpdateOperationField`
+ * by recursively iterating the `object` fields. Then invokes the `createDocument`
+ * callback to delegate the creation if CSI document.
+ *
+ * If the `object` has fields of type `reference` or `model` with the special
+ * `$$type` property holding the model name of the nested object, this function
+ * will recursively create new documents and nested objects for these fields.
+ * Other fields of will be used to populate the fields of the new document or
+ * nested object.
+ *
+ * @example
+ * {
+ *     title: 'hello world',
+ *     button: {
+ *         $$type: 'Button',   // a new nested object of type Button will be
+ *         label: 'Click me'   // created with 'label' field set to 'Click me'
+ *     }
+ * }
+ *
+ * If the `object` has fields of type `reference` or `image` with the special
+ * `$$ref` property holding an ID of an existing document, this function will
+ * link an existing documents or assets with that ID.
+ *
+ * @example
+ * {
+ *     title: 'hello world',
+ *     author: {
+ *         $$ref: 'xyz'        // the 'author' field will be linked to a document
+ *                             // with ID 'xyz'
+ *     }
+ * }
+ *
+ * Returns an object with two fields:
+ * 1. `document` holding the created CSITypes.Document for the passed object.
+ * 2. `newRefDocuments` holding list of created CSITypes.Document that were
+ *    created recursively for `reference` fields having the `$$type` property.
+ */
+export async function createDocumentRecursively({
+    object,
+    modelName,
+    modelMap,
+    createDocument
+}: {
+    object?: Record<string, any>;
+    modelName: string;
+    modelMap: Record<string, Model>;
+    createDocument: CreateDocumentCallback;
+}): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
+    const model = modelMap[modelName];
+    if (!model) {
+        throw new Error(`no model with name '${modelName}' was found`);
+    }
+    if (model.type === 'page') {
+        const tokens = extractTokensFromString(String(model.urlPath));
+        const slugField = _.last(tokens);
+        if (object && slugField && slugField in object) {
+            const slugFieldValue = object[slugField];
+            object[slugField] = sanitizeSlug(slugFieldValue);
+        }
+    }
+
+    const nestedResult = await createNestedObjectRecursively({
+        object,
+        modelFields: model.fields ?? [],
+        fieldPath: [],
+        modelMap,
+        createDocument
+    });
+
+    const document = await createDocument({
+        updateOperationFields: nestedResult.fields,
+        modelName: modelName
+    });
+    return {
+        document: document,
+        newRefDocuments: nestedResult.newRefDocuments
+    };
+}
+
+function extractTokensFromString(input: string): string[] {
+    return input.match(/(?<={)[^}]+(?=})/g) || [];
+}
+
+function sanitizeSlug(slug: string) {
+    return slug
+        .split('/')
+        .map((part) => slugify(part, { lower: true }))
+        .join('/');
+}
+
+async function createNestedObjectRecursively({
+    object,
+    modelFields,
+    fieldPath,
+    modelMap,
+    createDocument
+}: {
+    object?: Record<string, any>;
+    modelFields: Field[];
+    fieldPath: (string | number)[];
+    modelMap: Record<string, Model>;
+    createDocument: CreateDocumentCallback;
+}): Promise<{
+    fields: Record<string, CSITypes.UpdateOperationField>;
+    newRefDocuments: CSITypes.Document[];
+}> {
+    object = object ?? {};
+    const result: {
+        fields: Record<string, CSITypes.UpdateOperationField>;
+        newRefDocuments: CSITypes.Document[];
+    } = {
+        fields: {},
+        newRefDocuments: []
+    };
+    const objectFieldNames = Object.keys(object);
+    for (const modelField of modelFields) {
+        const fieldName = modelField.name;
+        let value;
+        if (fieldName in object) {
+            value = object[fieldName];
+            _.pull(objectFieldNames, fieldName);
+        } else if (modelField.const) {
+            value = modelField.const;
+        } else if (!_.isNil(modelField.default)) {
+            value = modelField.default;
+        }
+        if (!_.isNil(value)) {
+            const fieldResult = await createNestedField({
+                value,
+                modelField,
+                fieldPath: fieldPath.concat(fieldName),
+                modelMap,
+                createDocument
+            });
+            result.fields[fieldName] = fieldResult.field;
+            result.newRefDocuments = result.newRefDocuments.concat(fieldResult.newRefDocuments);
+        }
+    }
+    if (objectFieldNames.length > 0) {
+        throw new Error(`no model fields found when creating a document with fields: '${objectFieldNames.join(', ')}'`);
+    }
+
+    return result;
+}
+
+async function createNestedField({
+    value,
+    modelField,
+    fieldPath,
+    modelMap,
+    createDocument
+}: {
+    value: any;
+    modelField: FieldSpecificProps;
+    fieldPath: (string | number)[];
+    modelMap: Record<string, Model>;
+    createDocument: CreateDocumentCallback;
+}): Promise<{ field: CSITypes.UpdateOperationField; newRefDocuments: CSITypes.Document[] }> {
+    if (modelField.type === 'object') {
+        const result = await createNestedObjectRecursively({
+            object: value,
+            modelFields: modelField.fields,
+            fieldPath,
+            modelMap,
+            createDocument
+        });
+        return {
+            field: {
+                type: 'object',
+                fields: result.fields
+            },
+            newRefDocuments: result.newRefDocuments
+        };
+    } else if (modelField.type === 'model') {
+        let { $$type, ...rest } = value;
+        const modelNames = modelField.models;
+        // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
+        // the 'type' property in default values
+        if (!$$type && 'type' in rest) {
+            $$type = rest.type;
+            rest = _.omit(rest, 'type');
+        }
+        const modelName = $$type ?? (modelNames.length === 1 ? modelNames[0] : null);
+        if (!modelName) {
+            throw new Error(`no $$type was specified for nested model`);
+        }
+        const model = modelMap[modelName];
+        if (!model) {
+            throw new Error(`no model with name '${modelName}' was found`);
+        }
+        const result = await createNestedObjectRecursively({
+            object: rest,
+            modelFields: model.fields ?? [],
+            fieldPath,
+            modelMap,
+            createDocument
+        });
+        return {
+            field: {
+                type: 'model',
+                modelName: modelName,
+                fields: result.fields
+            },
+            newRefDocuments: result.newRefDocuments
+        };
+    } else if (modelField.type === 'image') {
+        let refId: string | undefined;
+        if (_.isPlainObject(value)) {
+            refId = value.$$ref;
+        } else {
+            refId = value;
+        }
+        if (!refId) {
+            throw new Error(`reference field must specify a value`);
+        }
+        return {
+            field: {
+                type: 'reference',
+                refType: 'asset',
+                refId: refId
+            },
+            newRefDocuments: []
+        };
+    } else if (modelField.type === 'reference') {
+        let { $$ref: refId = null, $$type: modelName = null, ...rest } = _.isPlainObject(value) ? value : { $$ref: value };
+        if (refId) {
+            return {
+                field: {
+                    type: 'reference',
+                    refType: 'document',
+                    refId: refId
+                },
+                newRefDocuments: []
+            };
+        } else {
+            const modelNames = modelField.models;
+            if (!modelName) {
+                // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
+                // the 'type' property in default values
+                if ('type' in rest) {
+                    modelName = rest.type;
+                    rest = _.omit(rest, 'type');
+                } else if (modelNames.length === 1) {
+                    modelName = modelNames[0];
+                }
+            }
+            const { document, newRefDocuments } = await createDocumentRecursively({
+                object: rest,
+                modelName,
+                modelMap,
+                createDocument
+            });
+            return {
+                field: {
+                    type: 'reference',
+                    refType: 'document',
+                    refId: document.id
+                },
+                newRefDocuments: [document, ...newRefDocuments]
+            };
+        }
+    } else if (modelField.type === 'list') {
+        if (!Array.isArray(value)) {
+            throw new Error(`value for list field must be array`);
+        }
+        const itemsField = modelField.items;
+        if (!itemsField) {
+            throw new Error(`list field does not define items`);
+        }
+        const arrayResult = await mapPromise(
+            value,
+            async (item, index): Promise<{ field: UpdateOperationListFieldItem; newRefDocuments: CSITypes.Document[] }> => {
+                const result = await createNestedField({
+                    value: item,
+                    modelField: itemsField,
+                    fieldPath: fieldPath.concat(index),
+                    modelMap,
+                    createDocument
+                });
+                if (result.field.type === 'list') {
+                    throw new Error('list cannot have list as immediate child');
+                }
+                return {
+                    field: result.field,
+                    newRefDocuments: result.newRefDocuments
+                };
+            }
+        );
+        return {
+            field: {
+                type: 'list',
+                items: arrayResult.map((result) => result.field)
+            },
+            newRefDocuments: arrayResult.reduce((result: CSITypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
+        };
+    }
+    return {
+        field: {
+            type: modelField.type,
+            value: value
+        },
+        newRefDocuments: []
+    };
+}
+
+export async function convertOperationField({
+    operationField,
+    fieldPath,
+    modelField,
+    modelMap,
+    createDocument
+}: {
+    operationField: ContentStoreTypes.UpdateOperationField;
+    fieldPath: (string | number)[];
+    modelField: Field;
+    modelMap: Record<string, Model>;
+    createDocument: CreateDocumentCallback;
+}): Promise<CSITypes.UpdateOperationField> {
+    // for insert operations, the modelField will be of the list, so get the modelField of the list items
+    const modelFieldOrListItems: FieldSpecificProps = modelField.type === 'list' ? modelField.items! : modelField;
+    switch (operationField.type) {
+        case 'object': {
+            const result = await createNestedObjectRecursively({
+                object: operationField.object,
+                modelFields: (modelFieldOrListItems as FieldObjectProps).fields,
+                fieldPath: fieldPath,
+                modelMap,
+                createDocument
+            });
+            return {
+                type: operationField.type,
+                fields: result.fields
+            };
+        }
+        case 'model': {
+            const model = modelMap[operationField.modelName];
+            if (!model) {
+                throw new Error(`error updating document, could not find document model: '${operationField.modelName}'`);
+            }
+            const result = await createNestedObjectRecursively({
+                object: operationField.object,
+                modelFields: model.fields!,
+                fieldPath,
+                modelMap,
+                createDocument
+            });
+            return {
+                type: operationField.type,
+                modelName: operationField.modelName,
+                fields: result.fields
+            };
+        }
+        case 'list': {
+            if (modelField.type !== 'list') {
+                throw new Error(`'the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
+            }
+            const result: UpdateOperationListFieldItem[] = await mapPromise(
+                operationField.items,
+                async (item): Promise<UpdateOperationListFieldItem> => {
+                    const result = await createNestedField({
+                        value: item,
+                        modelField: modelField.items!,
+                        fieldPath,
+                        modelMap,
+                        createDocument
+                    });
+                    if (result.field.type === 'list') {
+                        throw new Error('list cannot have list as immediate child');
+                    }
+                    return result.field;
+                }
+            );
+            return {
+                type: operationField.type,
+                items: result
+            };
+        }
+        case 'string':
+            // When inserting new string value into a list, the client does not
+            // send value. Set an empty string value.
+            if (typeof operationField.value !== 'string') {
+                return {
+                    type: operationField.type,
+                    value: ''
+                };
+            }
+            return operationField as CSITypes.UpdateOperationField;
+        case 'enum':
+            // When inserting new enum value into a list, the client does not
+            // send value. Set first option as the value.
+            if (typeof operationField.value !== 'string') {
+                if (modelFieldOrListItems.type !== 'enum') {
+                    throw new Error(`'the operation field type 'enum' does not match the model field type '${modelFieldOrListItems.type}'`);
+                }
+                const option = modelFieldOrListItems.options[0]!;
+                const optionValue = typeof option === 'object' ? option.value : option;
+                return {
+                    type: operationField.type,
+                    value: optionValue
+                };
+            }
+            return operationField as CSITypes.UpdateOperationField;
+        case 'image':
+            return operationField as CSITypes.UpdateOperationField;
+        default:
+            return operationField as CSITypes.UpdateOperationField;
+    }
+}