matcha-keystone-utils/dist/history/history.js

Useful features for Keystone 6: validators, fields, componentBlocks...

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.afterOperationSaveHistory = exports.getHistoryEntity = void 0;
/* eslint-disable */
// @ts-nocheck
const core_1 = require("@keystone-6/core");
const fields_1 = require("@keystone-6/core/fields");
/*
TODO:
- Bug "go to item" for boost campaign
- Code cleanup
- Add session user
- Add session user access to history (remove allowAll)
- Check what happens if user is deleted
- Check what happens when no user
- Interface cleanup
- Move to utils project
- Try "restore before" and "restore after"
- Ignore password
 */
const operations = [
    { value: "create", label: "👶 Create" },
    { value: "update", label: "💇 Update" },
    { value: "delete", label: "🧓 Delete" },
];
const pluralNameQuery = `
query ($key: String!) {
  keystone {
    adminMeta {
      list(key: $key) {
        key
        plural
      }
    }
  }
}
`;
const getNameDate = date => date.toISOString().slice(0, 16).replace("T", " ");
const getHistoryEntity = (listConfig) => (0, core_1.list)({
    ...listConfig,
    fields: {
        name: (0, fields_1.virtual)({
            field: core_1.graphql.field({
                type: core_1.graphql.String,
                resolve: ({ entity, date, operation }) => `[${operation} in ${entity}] ${getNameDate(date)}`,
            }),
            ui: {
                listView: { fieldMode: "hidden" },
            },
        }),
        date: (0, fields_1.timestamp)(),
        user: (0, fields_1.relationship)({ ref: "User" }),
        entity: (0, fields_1.text)(),
        entityId: (0, fields_1.text)(),
        operation: (0, fields_1.select)({ options: operations }),
        before: (0, fields_1.json)({ label: "Before [originalItem]" }),
        after: (0, fields_1.json)({ label: "After [item]" }),
        inputData: (0, fields_1.json)({ label: "Modified [inputData]" }),
        resolvedData: (0, fields_1.json)({ label: "Resolved [resolvedData]" }),
        item: (0, fields_1.virtual)({
            field: core_1.graphql.field({
                type: core_1.graphql.object()({
                    name: "ItemData",
                    fields: {
                        type: core_1.graphql.field({ type: core_1.graphql.String }),
                        plural: core_1.graphql.field({ type: core_1.graphql.String }),
                        entityId: core_1.graphql.field({ type: core_1.graphql.String }),
                    },
                }),
                resolve: async (item, args, context) => {
                    const { entityId, entity } = item;
                    // console.log(context.)
                    const keystoneMetaResponse = await context.graphql.run({
                        query: pluralNameQuery,
                        variables: { key: entity },
                    });
                    const listMeta = keystoneMetaResponse.keystone.adminMeta.list;
                    const plural = listMeta?.plural;
                    const itemz = listMeta &&
                        (await context.query[entity].findOne({
                            where: { id: entityId },
                        }));
                    const type = item.operation === "delete"
                        ? "itemDeletedNow"
                        : listMeta
                            ? itemz
                                ? "itemExists"
                                : "itemDeletedLater"
                            : "entityDeleted";
                    return { type, plural, entityId };
                },
            }),
            ui: {
                query: "{ type plural entityId }",
                // TODO: kludge, try using clean package exports instead, like:
                // https://github.com/keystonejs/keystone/blob/main/packages/cloudinary/views/package.json
                views: process.env.IS_LIBRARY_DEV
                    ? "./src/history/item"
                    : "matcha-keystone-utils/dist/history/item",
            },
        }),
    },
    ui: {
        listView: {
            initialColumns: ["user", "item", "operation", "date"],
            initialSort: { field: "date", direction: "DESC" },
        },
        hideCreate: true,
        hideDelete: true,
    },
    hooks: {
        validateInput: ({ operation, addValidationError }) => {
            if (operation === "update")
                addValidationError("You cannot rewrite History, you fascist!");
        },
    },
});
exports.getHistoryEntity = getHistoryEntity;
const afterOperationSaveHistory = async ({ listKey, operation, originalItem, item, inputData, resolvedData, context, }) => {
    // console.log("operation", operation)
    // console.log("listKey", listKey)
    // console.log("inputData", inputData)
    // console.log("resolvedData", resolvedData)
    // console.log("item", item)
    // console.log("originalItem", originalItem)
    // console.log("context.session", context.session)
    const entityId = item?.id || originalItem?.id || "";
    const userId = context.session?.data?.id;
    const history = {
        date: new Date(),
        user: userId ? { connect: { id: userId } } : null,
        entity: listKey,
        entityId,
        operation,
        before: originalItem,
        after: item,
        inputData,
        resolvedData,
    };
    await context.sudo().db.History.createOne({ data: history });
};
exports.afterOperationSaveHistory = afterOperationSaveHistory;