tinybase 4.4.0-beta.0 → 4.4.0-beta.1

package/lib/types/with-schemas/persisters/persister-partykit-client.d.ts

@@ -23,6 +23,91 @@ import {OptionalSchemas, Store} from '../store';
 import PartySocket from 'partysocket';
 import {Persister} from '../persisters';
 
+/**
+ * The PartyKitPersister interface is a minor extension to the Persister
+ * interface.
+ *
+ * It simply provides an extra getConnection method for accessing the
+ * PartySocket the Store is being persisted to.
+ * @since v4.3.14
+ */
+export interface PartyKitPersister<Schemas extends OptionalSchemas>
+  extends Persister<Schemas> {
+  /**
+   * The getConnection method returns the PartySocket the Store is being
+   * persisted to.
+   * @returns The PartySocket.
+   * @example
+   * This example creates a Persister object against a newly-created Store and
+   * then gets the PartySocket back out again.
+   *
+   * ```js yolo
+   * const partySocket = new PartySocket({
+   *   host: PARTYKIT_HOST,
+   *   room: 'my_room',
+   * });
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const persister = createPartyKitPersister(store, partySocket);
+   *
+   * console.log(persister.getConnection() == partySocket);
+   * // -> true
+   *
+   * persister.destroy();
+   * ```
+   * @category Getter
+   * @since v4.3.14
+   */
+  getConnection: () => PartySocket;
+}
+
+/**
+ * The PartyKitPersisterConfig type describes the configuration of a PartyKit
+ * Persister on the client side.
+ *
+ * The defaults (if used on both the server and client) will work fine, but if
+ * you are building more complex PartyKit apps and you need to configure path
+ * names, for example, then this is the thing to use.
+ * @example
+ * When applied to a PartyKit Persister, this PartyKitPersisterConfig will load
+ * and save a JSON serialization from and to an end point in your room called
+ * `/my_tinybase`, and use HTTP (rather than the default HTTPS) as the protocol.
+ *
+ * Note that this would require you to also add the matching storePath setting
+ * to the TinyBasePartyKitServerConfig on the server side.
+ *
+ * ```js
+ * const partyKitPersisterConfig = {
+ *   storeProtocol: 'http',
+ *   storePath: '/my_tinybase',
+ * };
+ * ```
+ * @category Configuration
+ * @since v4.3.9
+ */
+export type PartyKitPersisterConfig = {
+  /**
+   * The HTTP protocol to use (in addition to the websocket channel). This
+   * defaults to 'https' but you may wish to use 'http' for local PartyKit
+   * development.
+   */
+  storeProtocol?: 'http' | 'https';
+  /**
+   * The path used to set and get the whole Store over HTTP(S) on the server.
+   * This must match the storePath property of the TinyBasePartyKitServerConfig
+   * object used on the server. Both default to '/store'.
+   */
+  storePath?: string;
+  /**
+   * The prefix at the beginning of the web socket messages sent between the
+   * client and the server when synchronizing the Store. Use this to make sure
+   * they do not collide with any other message syntax that your room is using.
+   * This must match the messagePrefix property of the
+   * TinyBasePartyKitServerConfig object used on the server. Both default to an
+   * empty string.
+   */
+  messagePrefix?: string;
+};
+
 /**
  * The createPartyKitPersister function creates a Persister object that can
  * persist the Store to durable PartyKit storage, enabling synchronization of
@@ -34,9 +119,9 @@ import {Persister} from '../persisters';
  * createPartyKitPersister(
  *   store: Store,
  *   connection: PartySocket,
- *   storeUrlProtocol?: 'http' | 'https',
+ *   configOrStoreProtocol?: PartyKitPersisterConfig | 'http' | 'https',
  *   onIgnoredError?: (error: any) => void,
- * ): Persister;
+ * ): PartyKitPersister;
  * ```
  *
  * As well as providing a reference to the Store to persist, you must provide a
@@ -63,24 +148,26 @@ import {Persister} from '../persisters';
  * @param store The Store to persist.
  * @param connection The PartySocket to use for participating in the PartyKit
  * room.
- * @param storeUrlProtocol The HTTP protocol to use (in addition to the
- * websocket channel). This defaults to 'https' but you may wish to use 'http'
- * for local PartyKit development.
+ * @param configOrStoreProtocol The PartyKitPersisterConfig configuration for
+ * the Persister, (or a string to specify a HTTP protocol to use, defaulting to
+ * 'https').
  * @param onIgnoredError An optional handler for the errors that the Persister
  * would otherwise ignore when trying to save or load data. This is suitable for
  * debugging persistence issues in a development environment.
- * @returns A reference to the new Persister object.
+ * @returns A reference to the new PartyKitPersister object.
  * @example
- * This example creates a Persister object and persists the Store to the
+ * This example creates a PartyKitPersister object and persists the Store to the
  * browser's IndexedDB storage.
  *
  * ```js yolo
- * const store =
- *   createStore()
- *     .setTable('pets', {fido: {species: 'dog'}})
- *     .setTable('species', {dog: {price: 5}})
- *     .setValues({open: true});
- * const partySocket = new PartySocket({host: PARTYKIT_HOST, room: 'my_room'});
+ * const store = createStore()
+ *   .setTable('pets', {fido: {species: 'dog'}})
+ *   .setTable('species', {dog: {price: 5}})
+ *   .setValues({open: true});
+ * const partySocket = new PartySocket({
+ *   host: PARTYKIT_HOST,
+ *   room: 'my_room',
+ * });
  * const persister = createPartyKitPersister(store, partySocket);
  * await persister.startAutoLoad();
  * await persister.startAutoSave();
@@ -94,6 +181,6 @@ import {Persister} from '../persisters';
 export function createPartyKitPersister<Schemas extends OptionalSchemas>(
   store: Store<Schemas>,
   connection: PartySocket,
-  storeUrlProtocol?: 'http' | 'https',
+  configOrStoreProtocol?: PartyKitPersisterConfig | 'http' | 'https',
   onIgnoredError?: (error: any) => void,
-): Persister<Schemas>;
+): PartyKitPersister<Schemas>;

package/lib/types/with-schemas/persisters/persister-partykit-server.d.ts

@@ -18,7 +18,83 @@
  * @since 4.3.0
  */
 
-import {Connection, Request, Server} from 'partykit/server';
+import {
+  Cell,
+  CellOrUndefined,
+  NoTablesSchema,
+  NoValuesSchema,
+  Value,
+  ValueOrUndefined,
+} from '../store';
+import {Connection, Party, Request, Server} from 'partykit/server';
+import {Id} from '../common';
+
+/**
+ * The TinyBasePartyKitServerConfig type describes the configuration of a
+ * PartyKit Persister on the server side.
+ *
+ * The defaults (if used on both the server and client) will work fine, but if
+ * you are building more complex PartyKit apps and you need to configure path
+ * names, for example, then this is the type to use.
+ * @example
+ * When set as the config in a TinyBasePartyKitServer, this
+ * TinyBasePartyKitServerConfig will expect clients to load and save their JSON
+ * serialization from and to an end point in the room called `/my_tinybase`.
+ * Note that this would require you to also add the matching storePath setting
+ * to the PartyKitPersisterConfig on the client side.
+ *
+ * It will also store the data in the durable storage with a prefix of
+ * 'tinybase_' in case you are worried about colliding with other data stored
+ * in the room.
+ *
+ * ```js
+ * class MyServer extends TinyBasePartyKitServer {
+ *   readonly config = {
+ *     storePath: '/my_tinybase',
+ *     storagePrefix: 'tinybase_',
+ *   };
+ * }
+ * ```
+ * @category Configuration
+ * @since v4.3.9
+ */
+export type TinyBasePartyKitServerConfig = {
+  /**
+   * The path used to set and get the whole Store over HTTP(S) on the server.
+   * This must match the storePath property of the PartyKitPersisterConfig used
+   * on the client. Both default to '/store'.
+   */
+  storePath?: string;
+  /**
+   * The prefix at the beginning of the web socket messages between the client
+   * and the server when synchronizing the Store. Use this to make sure they do
+   * not collide with any other message syntax that your room is using. This
+   * must match the messagePrefix property of the PartyKitPersisterConfig object
+   * used on the client. Both default to an empty string.
+   */
+  messagePrefix?: string;
+  /**
+   * The prefix used before all the keys in the server's durable storage. Use
+   * this in case you are worried about the Store data colliding with other data
+   * stored in the room. Defaults to an empty string.
+   */
+  storagePrefix?: string;
+  /**
+   * An object containing the extra HTTP(S) headers returned to the client from
+   * this server. This defaults to the following three headers to allow CORS:
+   *
+   * ```
+   * Access-Control-Allow-Origin: *
+   * Access-Control-Allow-Methods: *
+   * Access-Control-Allow-Headers: *
+   * ```
+   *
+   * If you set this field, it will override the default completely. So, for
+   * example, if you add another header but still want the CORS defaults, you
+   * will need to explicitly set the Access-Control-Allow headers above again.
+   */
+  responseHeaders?: HeadersInit;
+};
 
 /**
  * A TinyBasePartyKitServer is the server component for persisting the Store to
@@ -39,7 +115,7 @@ import {Connection, Request, Server} from 'partykit/server';
  * ```js
  * // This is your PartyKit server entry point.
  *
- * export default class extends TinyBasePartyServer {
+ * class MyServer extends TinyBasePartyKitServer {
  *   constructor(party) {
  *     super(party);
  *     // custom constructor code
@@ -50,8 +126,8 @@ import {Connection, Request, Server} from 'partykit/server';
  *     console.log('Server started');
  *   }
  *
- *   async onMessage(message, client) {
- *     await super.onMessage(message, client);
+ *   async onMessage(message, connection) {
+ *     await super.onMessage(message, connection);
  *     // custom onMessage code
  *   }
  *
@@ -65,8 +141,20 @@ import {Connection, Request, Server} from 'partykit/server';
  * See the [PartyKit server API
  * documentation](https://docs.partykit.io/reference/partyserver-api/) for
  * more details.
+ * @category Creation
+ * @since v4.3.0
  */
 export class TinyBasePartyKitServer implements Server {
+  constructor(party: Party);
+  /**
+   * The config property is used to optionally configure the server, using an
+   * object of the TinyBasePartyKitServerConfig type.
+   *
+   * See the documentation for that type for more details.
+   * @category Configuration
+   * @since v4.3.9
+   */
+  readonly config: TinyBasePartyKitServerConfig;
   /**
    * The onRequest method is called when a HTTP request is made to the party
    * URL.
@@ -76,7 +164,7 @@ export class TinyBasePartyKitServer implements Server {
    * synchronization stays supported:
    *
    * ```js
-   * export default class extends TinyBasePartyServer {
+   * class MyServer extends TinyBasePartyKitServer {
    *   async onRequest(request) {
    *     // custom onRequest code, else:
    *     return await super.onRequest(request);
@@ -87,6 +175,8 @@ export class TinyBasePartyKitServer implements Server {
    * See the [PartyKit server API
    * documentation](https://docs.partykit.io/reference/partyserver-api/) for
    * more details.
+   * @category Connection
+   * @since v4.3.0
    */
   onRequest(request: Request): Promise<Response>;
   /**
@@ -98,9 +188,9 @@ export class TinyBasePartyKitServer implements Server {
    * synchronization stays supported:
    *
    * ```js
-   * export default class extends TinyBasePartyServer {
-   *   async onMessage(message, client) {
-   *     await super.onMessage(message, client);
+   * class MyServer extends TinyBasePartyKitServer {
+   *   async onMessage(message, connection) {
+   *     await super.onMessage(message, connection);
    *     // custom onMessage code
    *   }
    * }
@@ -109,6 +199,354 @@ export class TinyBasePartyKitServer implements Server {
    * See the [PartyKit server API
    * documentation](https://docs.partykit.io/reference/partyserver-api/) for
    * more details.
+   * @category Connection
+   * @since v4.3.0
+   */
+  onMessage(message: string, connection: Connection): Promise<void>;
+  /**
+   * The canSetTable method lets you allow or disallow any changes to a Table
+   * stored on the server, as sent from a client.
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Table Id that the client is trying to change. The
+   * `initialSave` parameter distinguishes between the first bulk save of the
+   * Store to the PartyKit room over HTTP (`true`), and subsequent incremental
+   * updates over a web sockets (`false`).
+   *
+   * The `requestOrConnection` parameter will either be the HTTP(S) request or
+   * the web socket connection, in those two cases respectively. You can, for
+   * instance, use this to distinguish between different users.
+   *
+   * Since v4.3.13, the final parameter is the Cell previously stored on the
+   * server, if any. Use this to distinguish between the addition of a new Cell
+   * (in which case it will be undefined) and the updating of an existing one.
+   *
+   * Return `false` from this method to disallow changes to this Table on the
+   * server, or `true` to allow them (subject to subsequent canSetRow method,
+   * canDelRow method, canSetCell method, and canSetCell method checks). The
+   * default implementation returns `true` to allow all changes.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * update any 'user' tabular data after the initial save:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canSetTable(tableId, initialSave) {
+   *     return initialSave || tableId != 'user';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canSetTable(
+    tableId: Id,
+    initialSave: boolean,
+    requestOrConnection: Request | Connection,
+  ): boolean;
+  /**
+   * The canDelTable method lets you allow or disallow deletions of a Table
+   * stored on the server, as sent from a client.
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Table Id that the client is trying to delete. The
+   * `connection` parameter will be the web socket connection of that client.
+   * You can, for instance, use this to distinguish between different users.
+   *
+   * Return `false` from this method to disallow this Table from being deleted
+   * on the server, or `true` to allow it. The default implementation returns
+   * `true` to allow deletion.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * delete the 'user' Table:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canDelTable(tableId) {
+   *     return tableId != 'user';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canDelTable(tableId: Id, connection: Connection): boolean;
+  /**
+   * The canSetRow method lets you allow or disallow any changes to a Row stored
+   * on the server, as sent from a client.
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Table Id and Row Id that the client is trying to
+   * change. The `initialSave` parameter distinguishes between the first bulk
+   * save of the Store to the PartyKit room over HTTP (`true`), and subsequent
+   * incremental updates over a web sockets (`false`).
+   *
+   * The final `requestOrConnection` parameter will either be the HTTP(S)
+   * request or the web socket connection, in those two cases respectively. You
+   * can, for instance, use this to distinguish between different users.
+   *
+   * Return `false` from this method to disallow changes to this Row on the
+   * server, or `true` to allow them (subject to subsequent canSetCell method
+   * and canSetCell method checks). The default implementation returns `true` to
+   * allow all changes.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * update the 'me' Row of the 'user' Table after the initial save:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canSetRow(tableId, rowId, initialSave) {
+   *     return initialSave || tableId != 'user' || rowId != 'me';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canSetRow(
+    tableId: Id,
+    rowId: Id,
+    initialSave: boolean,
+    requestOrConnection: Request | Connection,
+  ): boolean;
+  /**
+   * The canDelRow method lets you allow or disallow deletions of a Row stored
+   * on the server, as sent from a client.
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Table Id and Row Id that the client is trying to
+   * delete. The `connection` parameter will be the web socket connection of
+   * that client. You can, for instance, use this to distinguish between
+   * different users.
+   *
+   * Return `false` from this method to disallow this Row from being deleted
+   * on the server, or `true` to allow it. The default implementation returns
+   * `true` to allow deletion.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * delete the 'me' Row of the 'user' Table:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canDelRow(tableId, rowId) {
+   *     return tableId != 'user' || rowId != 'me';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canDelRow(tableId: Id, rowId: Id, connection: Connection): boolean;
+  /**
+   * The canSetCell method lets you allow or disallow any changes to a Cell
+   * stored on the server, as sent from a client.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * canSetCell(
+   *   tableId: Id,
+   *   rowId: Id,
+   *   cellId: Id,
+   *   cell: Cell,
+   *   initialSave: boolean,
+   *   requestOrConnection: Request | Connection,
+   *   oldCell: CellOrUndefined,
+   * ): boolean;
+   * ```
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Table Id, Row Id, and Cell Id that the client is
+   * trying to change - as well as the Cell value itself. The `initialSave`
+   * parameter distinguishes between the first bulk save of the Store to the
+   * PartyKit room over HTTP (`true`), and subsequent incremental updates over a
+   * web sockets (`false`).
+   *
+   * The final `requestOrConnection` parameter will either be the HTTP(S)
+   * request or the web socket connection, in those two cases respectively. You
+   * can, for instance, use this to distinguish between different users.
+   *
+   * Return `false` from this method to disallow changes to this Cell on the
+   * server, or `true` to allow them. The default implementation returns `true`
+   * to allow all changes.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * update the 'name' Cell of the 'me' Row of the 'user' Table after the
+   * initial save:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canSetCell(tableId, rowId, cellId, cell, initialSave) {
+   *     return (
+   *       initialSave || tableId != 'user' || rowId != 'me' || cellId != 'name'
+   *     );
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canSetCell(
+    tableId: Id,
+    rowId: Id,
+    cellId: Id,
+    cell: Cell<NoTablesSchema, Id, Id>,
+    initialSave: boolean,
+    requestOrConnection: Request | Connection,
+    oldCell: CellOrUndefined<NoTablesSchema, Id, Id>,
+  ): boolean;
+  /**
+   * The canDelCell method lets you allow or disallow deletions of a Cell stored
+   * on the server, as sent from a client.
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Table Id, Row Id, and Cell Id that the client is
+   * trying to delete. The `connection` parameter will be the web socket
+   * connection of that client. You can, for instance, use this to distinguish
+   * between different users.
+   *
+   * Return `false` from this method to disallow this Cell from being deleted on
+   * the server, or `true` to allow it. The default implementation returns
+   * `true` to allow deletion.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * delete the 'name' Cell of the 'me' Row of the 'user' Table:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canDelCell(tableId, rowId, cellId) {
+   *     return tableId != 'user' || rowId != 'me' || cellId != 'name';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canDelCell(
+    tableId: Id,
+    rowId: Id,
+    cellId: Id,
+    connection: Connection,
+  ): boolean;
+  /**
+   * The canSetValue method lets you allow or disallow any changes to a Value
+   * stored on the server, as sent from a client.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * canSetValue(
+   *   valueId: Id,
+   *   value: Value,
+   *   initialSave: boolean,
+   *   requestOrConnection: Request | Connection,
+   *   oldValue: ValueOrUndefined,
+   * ): boolean;
+   * ```
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Value Id that the client is trying to change - as
+   * well as the Value itself. The `initialSave` parameter distinguishes between
+   * the first bulk save of the Store to the PartyKit room over HTTP (`true`),
+   * and subsequent incremental updates over a web sockets (`false`).
+   *
+   * The `requestOrConnection` parameter will either be the HTTP(S) request or
+   * the web socket connection, in those two cases respectively. You can, for
+   * instance, use this to distinguish between different users.
+   *
+   * Since v4.3.13, the final parameter is the Value previously stored on the
+   * server, if any. Use this to distinguish between the addition of a new Value
+   * (in which case it will be undefined) and the updating of an existing one.
+   *
+   * Return `false` from this method to disallow changes to this Value on the
+   * server, or `true` to allow them. The default implementation returns `true`
+   * to allow all changes.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * update the 'userId' Value after the initial save:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canSetValue(valueId, value, initialSave) {
+   *     return initialSave || userId != 'userId';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
+   */
+  canSetValue(
+    valueId: Id,
+    value: Value<NoValuesSchema, Id>,
+    initialSave: boolean,
+    requestOrConnection: Request | Connection,
+    oldValue: ValueOrUndefined<NoValuesSchema, Id>,
+  ): boolean;
+  /**
+   * The canDelValue method lets you allow or disallow deletions of a Value
+   * stored on the server, as sent from a client.
+   *
+   * This is one of the functions use to sanitize the data that is being sent
+   * from a client. Perhaps you might want to make sure the server-stored data
+   * adheres to a particular schema, or you might want to make certain data
+   * read-only. Remember that you cannot trust the client to only send data that
+   * the server considers valid or safe.
+   *
+   * This method is passed the Value Id that the client is trying to delete. The
+   * `connection` parameter will be the web socket connection of that client.
+   * You can, for instance, use this to distinguish between different users.
+   *
+   * Return `false` from this method to disallow this Value from being deleted
+   * on the server, or `true` to allow it. The default implementation returns
+   * `true` to allow deletion.
+   * @example
+   * The following implementation will strip out any attempts by the client to
+   * delete the 'userId' Value:
+   *
+   * ```js
+   * class MyServer extends TinyBasePartyKitServer {
+   *   canDelValue(valueId) {
+   *     return valueId != 'userId';
+   *   }
+   * }
+   * ```
+   * @category Sanitization
+   * @since v4.3.12
    */
-  onMessage(message: string, client: Connection): void;
+  canDelValue(valueId: Id, connection: Connection): boolean;
 }