rimecms 0.31.4 → 0.32.0

package/dist/core/pipeline/hook-name.server.js

@@ -0,0 +1,14 @@
+/**
+ * A hook's declared name, or `anonymous`.
+ *
+ * All that is left of `marksOf`. Names are set on the function at runtime by `Hooks.*` rather than
+ * carried in its type — a function's own `name` is non-writable, so `declare` uses
+ * `defineProperty`, which also makes the hook show up under it in stack traces.
+ *
+ * The fallback is not defensive padding: a hook can reach a pipeline without having gone through
+ * `Hooks.*` at all, and a consumer's bare function is exactly that.
+ */
+export const hookName = (hook) => {
+    const named = hook;
+    return typeof named.name === 'string' && named.name ? named.name : 'anonymous';
+};

package/dist/core/pipeline/hooks/authorize.server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs the config's own access check for this operation, and throws `UNAUTHORIZED` if it says no.
+ *
+ * A system call stands down — `rime.collection('x').system()` is rime asking itself.
+ */
+export declare const authorize: import("../types").HookBeforeOperation<"raw", import("../types").Operation>;

package/dist/core/pipeline/hooks/authorize.server.js

@@ -0,0 +1,37 @@
+import { Hooks } from '../define-hook.js';
+import { RimeError } from '../../errors/index.js';
+import { logger } from '../../logger.server.js';
+/**
+ * Runs the config's own access check for this operation, and throws `UNAUTHORIZED` if it says no.
+ *
+ * A system call stands down — `rime.collection('x').system()` is rime asking itself.
+ */
+export const authorize = Hooks.beforeOperation(async function authorize(args) {
+    const { config, event, operation, context } = args;
+    let authorized = false;
+    const params = {
+        event,
+        id: context.params.id
+    };
+    if (args.context.isSystemOperation)
+        return args;
+    switch (operation) {
+        case 'create':
+            authorized = config.access.create(event.locals.user, params);
+            break;
+        case 'read':
+            authorized = config.access.read(event.locals.user, params);
+            break;
+        case 'update':
+            authorized = config.access.update(event.locals.user, params);
+            break;
+        case 'delete':
+            authorized = config.access.delete(event.locals.user, params);
+            break;
+    }
+    if (!authorized) {
+        logger.error(RimeError.UNAUTHORIZED);
+        throw new RimeError(RimeError.UNAUTHORIZED);
+    }
+    return args;
+});

package/dist/core/pipeline/hooks/data-config-map.server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Maps every path in the incoming data to the field builder that describes it, on
+ * `context.configMap`.
+ *
+ * What `setDefaultValues` and `validateFields` walk, and what the write turns into
+ * `incomingPaths` — the set of paths this request is allowed to touch.
+ */
+export declare const buildDataConfigMap: import("../types.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/pipeline/hooks/data-config-map.server.js

@@ -0,0 +1,19 @@
+import { Hooks } from '../define-hook.js';
+import { buildConfigMap } from '../config-map/index.js';
+/**
+ * Maps every path in the incoming data to the field builder that describes it, on
+ * `context.configMap`.
+ *
+ * What `setDefaultValues` and `validateFields` walk, and what the write turns into
+ * `incomingPaths` — the set of paths this request is allowed to touch.
+ */
+export const buildDataConfigMap = Hooks.beforeUpsert(async function buildDataConfigMap(args) {
+    const configMap = buildConfigMap(args.data, args.config.fields);
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            configMap
+        }
+    };
+});

package/dist/core/pipeline/hooks/get-original-document.server.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Loads the document an update is about to change: the row `versionId` names, else the newest
+ * one with `latest`, else the published one — selected exactly as a read selects, by
+ * `versionsReadQuery`. What is done to it is the next hook's, `defineVersionOperation`.
+ *
+ * Every prototype has one, so this step is core's. A document with no published version answers
+ * `not_found` to an update that selects the published one; `latest` is how to write it.
+ */
+export declare const getOriginalDocument: import("../types").Hook<"raw", "update", "before">;

package/dist/core/pipeline/hooks/get-original-document.server.js

@@ -0,0 +1,34 @@
+import { Hooks } from '../define-hook.js';
+import { RimeError } from '../../errors/index.js';
+/**
+ * Loads the document an update is about to change: the row `versionId` names, else the newest
+ * one with `latest`, else the published one — selected exactly as a read selects, by
+ * `versionsReadQuery`. What is done to it is the next hook's, `defineVersionOperation`.
+ *
+ * Every prototype has one, so this step is core's. A document with no published version answers
+ * `not_found` to an update that selects the published one; `latest` is how to write it.
+ */
+export const getOriginalDocument = Hooks.beforeUpdate(async function getOriginalDocument(args) {
+    const { event, config, context } = args;
+    const { rime } = event.locals;
+    const { id, locale, versionId, latest } = context.params;
+    let original;
+    switch (config.type) {
+        //
+        case 'collection':
+            if (!id)
+                throw new RimeError(RimeError.OPERATION_ERROR, 'missing id @getOriginalDocument');
+            original = await rime.collection(config.slug).findById({ locale, id, versionId, latest });
+            break;
+        case 'area':
+            original = await rime.area(config.slug).find({ locale, versionId, latest });
+            break;
+    }
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            originalDoc: original
+        }
+    };
+});

package/dist/core/pipeline/hooks/normalize-resolved-references.server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Writes a resolved reference as the id it stores.
+ *
+ * A read hands the referenced document back, and a save may send it back as it came:
+ *
+ * ```
+ * 'abc'                        'abc'
+ * { id: 'abc', name: 'Ann' }   'abc'
+ * '', null, { name: 'Ann' }    null
+ * ```
+ *
+ * A pipeline hook rather than a field `$beforeSave`: field hooks are skipped on the
+ * locale-fallback pass and under `?skipValidation`, and both still write the column.
+ */
+export declare const normalizeResolvedReferences: import("../types").Hook<"raw", "create" | "update", "before">;
+export declare const toReferenceId: (value: unknown) => string | null;

package/dist/core/pipeline/hooks/normalize-resolved-references.server.js

@@ -0,0 +1,40 @@
+import { Hooks } from '../define-hook.js';
+import { RimeError } from '../../errors/index.js';
+import { getValueAtPath, setValueAtPath } from '../../../util/object.js';
+/**
+ * Writes a resolved reference as the id it stores.
+ *
+ * A read hands the referenced document back, and a save may send it back as it came:
+ *
+ * ```
+ * 'abc'                        'abc'
+ * { id: 'abc', name: 'Ann' }   'abc'
+ * '', null, { name: 'Ann' }    null
+ * ```
+ *
+ * A pipeline hook rather than a field `$beforeSave`: field hooks are skipped on the
+ * locale-fallback pass and under `?skipValidation`, and both still write the column.
+ */
+export const normalizeResolvedReferences = Hooks.beforeUpsert(async function normalizeResolvedReferences(args) {
+    const configMap = args.context.configMap;
+    if (!configMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @normalizeResolvedReferences');
+    let data = { ...args.data };
+    for (const [path, config] of Object.entries(configMap)) {
+        if (!config._references?.resolve)
+            continue;
+        const value = getValueAtPath(path, data);
+        if (value === undefined)
+            continue;
+        data = setValueAtPath(path, data, toReferenceId(value));
+    }
+    return { ...args, data };
+});
+export const toReferenceId = (value) => {
+    if (typeof value === 'string')
+        return value || null;
+    if (value && typeof value === 'object' && typeof value.id === 'string') {
+        return value.id;
+    }
+    return null;
+};

package/dist/core/pipeline/hooks/original-config-map.server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The same map as `buildDataConfigMap`, over the document as it is now rather than as it is being
+ * sent — on `context.originalConfigMap`.
+ *
+ * What a step comparing the two needs: `prepareDataForNewVersion` reads it to carry forward a
+ * field the caller did not send.
+ */
+export declare const buildOriginalDocConfigMap: import("../types.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/pipeline/hooks/original-config-map.server.js

@@ -0,0 +1,23 @@
+import { Hooks } from '../define-hook.js';
+import { RimeError } from '../../errors/index.js';
+import { buildConfigMap } from '../config-map/index.js';
+/**
+ * The same map as `buildDataConfigMap`, over the document as it is now rather than as it is being
+ * sent — on `context.originalConfigMap`.
+ *
+ * What a step comparing the two needs: `prepareDataForNewVersion` reads it to carry forward a
+ * field the caller did not send.
+ */
+export const buildOriginalDocConfigMap = Hooks.beforeUpsert(async function buildOriginalDocConfigMap(args) {
+    const { originalDoc } = args.context;
+    if (!originalDoc)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @buildDataConfigMap');
+    const originalConfigMap = buildConfigMap(originalDoc, args.config.fields);
+    return {
+        ...args,
+        context: {
+            ...args.context,
+            originalConfigMap
+        }
+    };
+});

package/dist/core/pipeline/hooks/process-document-fields.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Walks every field of the document on the way out: drops what the reader may not see, fills an
+ * empty one from its default, and hands each value to the field's own `hooks.beforeRead`.
+ */
+export declare const processDocumentFields: import("../types.js").Hook<"raw", "read", "before">;

package/dist/core/pipeline/hooks/process-document-fields.server.js

@@ -0,0 +1,62 @@
+import { Hooks } from '../define-hook.js';
+import { logger } from '../../logger.server.js';
+import { deleteValueAtPath, getValueAtPath, setValueAtPath } from '../../../util/object.js';
+import { buildConfigMap } from '../config-map/index.js';
+import { getDefaultValue } from './set-default-values.server.js';
+/**
+ * Walks every field of the document on the way out: drops what the reader may not see, fills an
+ * empty one from its default, and hands each value to the field's own `hooks.beforeRead`.
+ */
+export const processDocumentFields = Hooks.beforeRead(async function processDocumentFields(args) {
+    const { event } = args;
+    let doc = args.doc;
+    const configMap = buildConfigMap(doc, args.config.fields);
+    for (const [key, config] of Object.entries(configMap)) {
+        let value = getValueAtPath(key, doc);
+        let isEmpty;
+        if (!config.use.accessRead(event.locals.user)) {
+            doc = deleteValueAtPath(doc, key);
+            continue;
+        }
+        if (value !== undefined && value !== null) {
+            value = await config.use.beforeRead(value, {
+                event,
+                operation: args.context,
+                documentId: doc.id
+            });
+            doc = setValueAtPath(key, doc, value);
+        }
+        try {
+            isEmpty = config.use.isEmpty(value);
+        }
+        catch {
+            isEmpty = false;
+            logger.warn(`Error in config.isEmpty for field ${key}`);
+        }
+        if (isEmpty && config.get.defaultValue !== undefined) {
+            value = await getDefaultValue({ key, config, adapter: args.event.locals.rime.adapter });
+            doc = setValueAtPath(key, doc, value);
+        }
+        if (config.type === 'blocks') {
+            const value = getValueAtPath(key, doc);
+            // Filter out possible undefined block or residual
+            // Case undefined : When in dev mode, if a block table is deleted in a migration, a blocks array value could includes undefined ex :
+            // * blocks: [ { ... }, undefined, { ... } ]
+            // * Because blocks are populated based on path.position
+            // Case residual : a block type has been removed but was including a relation, this gives ex :
+            // * blocks: [ { id:..., values,... }, { image: {...}} ]
+            //                                         ^
+            // * the image has been placed but the block doesn't exist anymore
+            if (value) {
+                const withoutResidualBlock = value
+                    .filter((b) => b && 'id' in b) // get only blocks that have .id
+                    .map((b, index) => ({
+                    ...b,
+                    position: index
+                }));
+                doc = setValueAtPath(key, doc, withoutResidualBlock);
+            }
+        }
+    }
+    return { ...args, doc };
+});

package/dist/core/pipeline/hooks/resolve-content-owner.server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Which row holds this document's content — the default, which is the document's own row.
+ *
+ * Every prototype has an answer to this, and for most of them it is this one. It was the `versions`
+ * feature answering it for everybody, through `handleNewVersion`'s `default:` branch, which is why
+ * both prototypes had to list a versions hook by name and why that hook could not be gated behind
+ * `enabled`: gating it left `contentOwnerId` unset on every non-versioned config, and `runUpdate`
+ * asserts it.
+ *
+ * With the default here, a feature that moves the content elsewhere *overrides* it — it requires
+ * `content-owner` and answers again — and a config that enables no such feature needs nothing from
+ * any feature at all.
+ *
+ * What reads it: `runUpdate` step 5 hangs blocks, tree nodes and relations off it, and both
+ * prototypes' `reread` fetches back the row the write went to.
+ */
+export declare const resolveContentOwner: import("../types").Hook<"raw", "update", "before">;

package/dist/core/pipeline/hooks/resolve-content-owner.server.js

@@ -0,0 +1,24 @@
+import { Hooks } from '../define-hook.js';
+import { RimeError } from '../../errors/index.js';
+/**
+ * Which row holds this document's content — the default, which is the document's own row.
+ *
+ * Every prototype has an answer to this, and for most of them it is this one. It was the `versions`
+ * feature answering it for everybody, through `handleNewVersion`'s `default:` branch, which is why
+ * both prototypes had to list a versions hook by name and why that hook could not be gated behind
+ * `enabled`: gating it left `contentOwnerId` unset on every non-versioned config, and `runUpdate`
+ * asserts it.
+ *
+ * With the default here, a feature that moves the content elsewhere *overrides* it — it requires
+ * `content-owner` and answers again — and a config that enables no such feature needs nothing from
+ * any feature at all.
+ *
+ * What reads it: `runUpdate` step 5 hangs blocks, tree nodes and relations off it, and both
+ * prototypes' `reread` fetches back the row the write went to.
+ */
+export const resolveContentOwner = Hooks.beforeUpdate(async function resolveContentOwner(args) {
+    const { originalDoc } = args.context;
+    if (!originalDoc)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing originalDoc @resolveContentOwner');
+    return { ...args, context: { ...args.context, contentOwnerId: originalDoc.id } };
+});

package/dist/core/pipeline/hooks/set-default-values.server.d.ts

@@ -0,0 +1,16 @@
+import type { Adapter } from '../../adapter.js';
+import type { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
+/**
+ * Fills in each field's `defaultValue` where the incoming data left it empty.
+ *
+ * A relation's default is one id or a list of them, and only the ids that name a document that
+ * exists survive — see `defaultRelationValue`.
+ */
+export declare const setDefaultValues: import("../types").Hook<"raw", "create" | "update", "before">;
+type GetDefaultValue = (args: {
+    key: string;
+    config: FormFieldBuilder;
+    adapter: Adapter;
+}) => Promise<any>;
+export declare const getDefaultValue: GetDefaultValue;
+export {};

package/dist/core/pipeline/hooks/set-default-values.server.js

@@ -0,0 +1,79 @@
+import { Hooks } from '../define-hook.js';
+import { getRequestEvent } from '$app/server';
+import { RimeError } from '../../errors/index.js';
+import { logger } from '../../logger.server.js';
+import { RelationFieldBuilder } from '../../../fields/relation/index.js';
+import { getValueAtPath, setValueAtPath } from '../../../util/object.js';
+/**
+ * Fills in each field's `defaultValue` where the incoming data left it empty.
+ *
+ * A relation's default is one id or a list of them, and only the ids that name a document that
+ * exists survive — see `defaultRelationValue`.
+ */
+export const setDefaultValues = Hooks.beforeUpsert(async function setDefaultValues(args) {
+    const { operation, event } = args;
+    const { rime } = event.locals;
+    const configMap = args.context.configMap;
+    if (!configMap)
+        throw new RimeError(RimeError.OPERATION_ERROR, 'missing configMap @setDefaultValues');
+    let output = { ...args.data };
+    for (const [key, config] of Object.entries(configMap)) {
+        let value = getValueAtPath(key, output);
+        let isEmpty;
+        const shouldAddDefault = operation === 'create' || (operation === 'update' && config.get.required);
+        try {
+            isEmpty = config.use.isEmpty(value);
+        }
+        catch {
+            isEmpty = false;
+            logger.warn(`Error in config.isEmpty for field ${key}`);
+        }
+        if (shouldAddDefault && isEmpty && config.get.defaultValue !== undefined) {
+            value = await getDefaultValue({ key, config, adapter: rime.adapter });
+            output = setValueAtPath(key, output, value);
+        }
+    }
+    return {
+        ...args,
+        data: output
+    };
+});
+/**
+ * This function convert any default value string | string[] of ids
+ * to a RelationValue from an existing relation record
+ */
+const defaultRelationValue = async (config, key, adapter) => {
+    const buildRelation = async (defaultValue) => {
+        // A default relation is one id or a list of them. Anything else names no document, and must
+        // not fall through to a `where(undefined)` that would hand back every row in the collection.
+        const ids = typeof defaultValue === 'string'
+            ? [defaultValue]
+            : Array.isArray(defaultValue)
+                ? defaultValue
+                : [];
+        // `existingIds` on the adapter, written out: which of these ids name a document that exists.
+        // The ordinary read, projected — see collection/nested/hooks/add-children.server.ts.
+        //
+        // `relationTo` is typed `CollectionSlug` by `RelationFieldBuilder.to`, so a relation names a
+        // collection by construction.
+        const existing = ids.length
+            ? await adapter
+                .collection(config.get.relationTo)
+                .findMany({ query: { where: { id: { in_array: ids } } }, select: ['id'] })
+            : [];
+        return existing.map(({ id: documentId }, index) => ({
+            id: null,
+            relationTo: config.get.relationTo,
+            path: key,
+            position: index,
+            documentId
+        }));
+    };
+    return await buildRelation(config.use.defaultValue({ event: getRequestEvent() }));
+};
+export const getDefaultValue = async ({ key, config, adapter }) => {
+    if (config instanceof RelationFieldBuilder) {
+        return await defaultRelationValue(config, key, adapter);
+    }
+    return config.use.defaultValue({ event: getRequestEvent() });
+};

package/dist/core/pipeline/hooks/set-document-locale.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Puts `locale` on the document, when the config is localized and the caller did not `select`
+ * their way out of it.
+ */
+export declare const setDocumentLocale: import("../types").Hook<"generic", "read", "before">;

package/dist/core/pipeline/hooks/set-document-locale.server.js

@@ -0,0 +1,19 @@
+import { Hooks } from '../define-hook.js';
+/**
+ * Puts `locale` on the document, when the config is localized and the caller did not `select`
+ * their way out of it.
+ */
+export const setDocumentLocale = Hooks.beforeRead(async function setDocumentLocale(args) {
+    let doc = args.doc;
+    // Set doc.locale only if :
+    // - locale is defined meaning that the config has a localized prop
+    // AND
+    // - the 'select' param includes 'locale' or no 'select' param at all
+    const hasSelect = Array.isArray(args.context.params.select) && args.context.params.select.length;
+    const locale = args.context.params.locale || args.event.locals.locale;
+    const shouldSetLocale = locale && !doc.locale && (!hasSelect || args.context.params.select?.includes('locale'));
+    if (shouldSetLocale) {
+        doc = { ...doc, locale: args.event.locals.locale };
+    }
+    return { ...args, doc };
+});

package/dist/core/pipeline/hooks/set-document-type.server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Puts `_prototype` and `_type` on the document — `'collection'` and its slug.
+ *
+ * Skipped entirely under a `select`: a caller naming the fields they want has not asked for these.
+ */
+export declare const setDocumentType: import("../types").Hook<"generic", "read", "before">;

package/dist/core/pipeline/hooks/set-document-type.server.js

@@ -0,0 +1,19 @@
+import { Hooks } from '../define-hook.js';
+/**
+ * Puts `_prototype` and `_type` on the document — `'collection'` and its slug.
+ *
+ * Skipped entirely under a `select`: a caller naming the fields they want has not asked for these.
+ */
+export const setDocumentType = Hooks.beforeRead(async function setDocumentType(args) {
+    const config = args.config;
+    let doc = args.doc;
+    const hasSelect = Array.isArray(args.context.params.select) && args.context.params.select.length;
+    if (!hasSelect) {
+        doc = {
+            ...doc,
+            _prototype: config.type,
+            _type: config.slug
+        };
+    }
+    return { ...args, doc };
+});

package/dist/core/pipeline/hooks/sort-document-props.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sorts every key of the document, at every depth, so a response is stable to diff.
+ *
+ * The finaliser: `buildPipeline` appends it after the consumer's own hooks, so nothing can run
+ * after it and unsort what it just sorted.
+ */
+export declare const sortDocumentProps: import("../types").Hook<"generic", "read", "before">;

package/dist/core/pipeline/hooks/sort-document-props.server.js

@@ -0,0 +1,71 @@
+import { Hooks } from '../define-hook.js';
+import { isObjectLiteral } from '../../../util/object.js';
+/**
+ * Sorts every key of the document, at every depth, so a response is stable to diff.
+ *
+ * The finaliser: `buildPipeline` appends it after the consumer's own hooks, so nothing can run
+ * after it and unsort what it just sorted.
+ */
+export const sortDocumentProps = Hooks.beforeRead(async function sortDocumentProps(args) {
+    return { ...args, doc: sortDocumentKeys(args.doc) };
+});
+function sortDocumentKeys(obj) {
+    const specificOrder = ['id', 'title', 'status'];
+    const endOrder = [
+        'locale',
+        'path',
+        'position',
+        'ownerId',
+        'createdBy',
+        'createdAt',
+        'updatedBy',
+        'updatedAt',
+        '_type',
+        '_prototype',
+        '_live',
+        '_children',
+        '_path',
+        '_parent',
+        '_position',
+        '_thumbnail'
+    ];
+    function sortObjectKeys(obj) {
+        // If not an object or is null, return the value as-is
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        // If array, process each object in the array
+        if (Array.isArray(obj)) {
+            return obj.map((item) => (typeof item === 'object' ? sortObjectKeys(item) : item));
+        }
+        // Sort the keys
+        const keys = Object.keys(obj).sort((a, b) => {
+            const aIndexSpecific = specificOrder.indexOf(a);
+            const bIndexSpecific = specificOrder.indexOf(b);
+            const aIndexEnd = endOrder.indexOf(a);
+            const bIndexEnd = endOrder.indexOf(b);
+            if (aIndexSpecific !== -1 && bIndexSpecific !== -1) {
+                return aIndexSpecific - bIndexSpecific;
+            }
+            if (aIndexEnd !== -1 && bIndexEnd !== -1) {
+                return aIndexEnd - bIndexEnd;
+            }
+            if (aIndexSpecific !== -1)
+                return -1;
+            if (bIndexSpecific !== -1)
+                return 1;
+            if (aIndexEnd !== -1)
+                return 1;
+            if (bIndexEnd !== -1)
+                return -1;
+            return a.localeCompare(b);
+        });
+        // Create new object with sorted keys
+        const sorted = {};
+        keys.forEach((key) => {
+            const shouldOrder = Array.isArray(obj[key]) || isObjectLiteral(obj[key]);
+            sorted[key] = shouldOrder ? sortObjectKeys(obj[key]) : obj[key];
+        });
+        return sorted;
+    }
+    return sortObjectKeys(obj);
+}

package/dist/core/pipeline/hooks/validate-fields.server.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Runs each field's `validate` and its write access check, and throws a `RimeFormError` carrying
+ * every message at once.
+ *
+ * A field the caller may not write is deleted from **both** the data and `context.configMap`.
+ * Leaving its path in the map would make the dropped write look like an explicit "nothing here
+ * any more" and delete the existing rows.
+ *
+ * `?skipValidation=true` skips it, as does the locale-fallback pass, which is re-writing a
+ * document that has already been through this once.
+ */
+export declare const validateFields: import("../types").Hook<"raw", "create" | "update", "before">;