velocious 1.0.493 → 1.0.494

package/build/src/sync/sync-attribute-normalizer.js

@@ -0,0 +1,172 @@
+// @ts-check
+import { snakeCaseKey } from "typanic";
+/**
+ * Builds the error thrown for a failed sync attribute validation.
+ * @callback SyncAttributeErrorFactory
+ * @param {string} message - Human-readable validation message.
+ * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.
+ * @returns {Error} Error to throw.
+ */
+/**
+ * Declarative validation schema for one writable sync attribute.
+ *
+ * Keys are camelCase attribute names; each attribute also accepts its
+ * snake_case column key on input (the camelCase key wins when both are given)
+ * and is written under the snake_case column key on output. Error messages
+ * default to `<label> ...` phrasings with `sync-<label>-...` codes, where the
+ * label defaults to the camelCase attribute name; apps pin exact messages per
+ * attribute through the `*Message` overrides.
+ * @typedef {object} SyncAttributeSchemaEntry
+ * @property {"date" | "json" | "raw" | "string"} type - Attribute value type.
+ * @property {boolean} [required] - Whether present blank/absent values are rejected (strings reject blank-after-trim, dates reject null).
+ * @property {number} [maxLength] - Maximum string length, checked after trimming.
+ * @property {string} [label] - Label used in derived messages and codes.
+ * @property {string} [column] - Output column key. Defaults to the snake_cased attribute name.
+ * @property {string} [requiredMessage] - Pinned message for required rejections.
+ * @property {string} [tooLongMessage] - Pinned message for too-long rejections.
+ * @property {string} [invalidMessage] - Pinned message for invalid dates and non-object/non-string json values.
+ * @property {string} [invalidJsonMessage] - Pinned message for unparseable json strings.
+ */
+/**
+ * Normalizes writable sync attributes against a declarative schema.
+ *
+ * Only present keys are validated, so required attributes may be absent —
+ * create defaults own that concern. Input keys not declared in the schema are
+ * rejected by default so misspelled or read-only attributes fail loudly
+ * instead of being silently discarded (`unknownAttributes: "ignore"` opts
+ * out). Validation failures throw through the given error factory so apps
+ * control the raised error class.
+ * @param {object} args - Options.
+ * @param {Record<string, ?>} args.attributes - Raw incoming attributes (camelCase and/or snake_case keys).
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Maps validation failures to thrown errors.
+ * @param {Record<string, SyncAttributeSchemaEntry>} args.schema - Attribute schema keyed by camelCase attribute name.
+ * @param {"error" | "ignore"} [args.unknownAttributes] - Unknown input-key handling. Defaults to "error".
+ * @returns {Record<string, ?>} Normalized values keyed by snake_case column names.
+ */
+export default function normalizeAttributesWithSchema({ attributes, errorFactory, schema, unknownAttributes = "error" }) {
+    if (!attributes || typeof attributes != "object")
+        throw new Error(`normalizeAttributesWithSchema requires an attributes object, got: ${String(attributes)}`);
+    if (typeof errorFactory != "function")
+        throw new Error("normalizeAttributesWithSchema requires an errorFactory function");
+    if (!schema || typeof schema != "object")
+        throw new Error(`normalizeAttributesWithSchema requires a schema object, got: ${String(schema)}`);
+    if (unknownAttributes != "error" && unknownAttributes != "ignore") {
+        throw new Error(`normalizeAttributesWithSchema unknownAttributes must be "error" or "ignore", got: ${String(unknownAttributes)}`);
+    }
+    /** @type {Record<string, ?>} */
+    const normalized = {};
+    /** @type {Set<string>} */
+    const knownInputKeys = new Set();
+    for (const [attributeName, entry] of Object.entries(schema)) {
+        const column = entry.column ?? snakeCaseKey(attributeName);
+        const inputKeys = column == attributeName ? [attributeName] : [column, attributeName];
+        for (const inputKey of inputKeys) {
+            knownInputKeys.add(inputKey);
+            if (!Object.prototype.hasOwnProperty.call(attributes, inputKey))
+                continue;
+            normalized[column] = normalizeAttributeValue({ attributeName, entry, errorFactory, value: attributes[inputKey] });
+        }
+    }
+    if (unknownAttributes == "error") {
+        for (const inputKey of Object.keys(attributes)) {
+            if (!knownInputKeys.has(inputKey)) {
+                throw errorFactory(`Unknown attribute: ${inputKey}.`, { code: "sync-unknown-attribute" });
+            }
+        }
+    }
+    return normalized;
+}
+/**
+ * Normalizes one present attribute value per its schema entry.
+ * @param {object} args - Options.
+ * @param {string} args.attributeName - camelCase attribute name.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {?} args.value - Raw value.
+ * @returns {?} Normalized value.
+ */
+function normalizeAttributeValue({ attributeName, entry, errorFactory, value }) {
+    const label = entry.label ?? attributeName;
+    if (entry.type == "string")
+        return normalizeString({ entry, errorFactory, label, value });
+    if (entry.type == "date")
+        return normalizeDate({ entry, errorFactory, label, value });
+    if (entry.type == "json")
+        return normalizeJson({ entry, errorFactory, label, value });
+    if (entry.type == "raw")
+        return value;
+    throw new Error(`Unknown sync attribute schema type for ${attributeName}: ${String(entry.type)}`);
+}
+/**
+ * Normalizes a string attribute: trims, rejects blank required values after trimming, maps empty optional values to null and bounds the trimmed length.
+ * @param {object} args - Options.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {string} args.label - Message/code label.
+ * @param {?} args.value - Raw value.
+ * @returns {string | null} Normalized string.
+ */
+function normalizeString({ entry, errorFactory, label, value }) {
+    const requiredError = () => errorFactory(entry.requiredMessage ?? `${label} is required.`, { code: `sync-${label}-required` });
+    if (value === null || value === undefined || value === "") {
+        if (entry.required)
+            throw requiredError();
+        return null;
+    }
+    const stringValue = String(value).trim();
+    if (stringValue === "") {
+        if (entry.required)
+            throw requiredError();
+        return null;
+    }
+    if (entry.maxLength !== undefined && stringValue.length > entry.maxLength) {
+        throw errorFactory(entry.tooLongMessage ?? `${label} is too long (maximum is ${entry.maxLength} characters).`, { code: `sync-${label}-too-long` });
+    }
+    return stringValue;
+}
+/**
+ * Normalizes a date attribute: Date instances pass through, strings/numbers are parsed and invalid or missing-required values are rejected.
+ * @param {object} args - Options.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {string} args.label - Message/code label.
+ * @param {?} args.value - Raw value.
+ * @returns {Date | null} Normalized date.
+ */
+function normalizeDate({ entry, errorFactory, label, value }) {
+    if (!entry.required && (value === null || value === undefined || value === ""))
+        return null;
+    const dateValue = value instanceof Date ? value : typeof value == "string" || typeof value == "number" ? new Date(value) : null;
+    if (!dateValue || Number.isNaN(dateValue.getTime())) {
+        throw errorFactory(entry.invalidMessage ?? `${label} must be a valid datetime.`, { code: `sync-${label}-invalid-datetime` });
+    }
+    return dateValue;
+}
+/**
+ * Normalizes a json attribute: empty values become null, objects pass through, strings must parse as JSON and other types are rejected.
+ * @param {object} args - Options.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {string} args.label - Message/code label.
+ * @param {?} args.value - Raw value.
+ * @returns {?} Normalized json value.
+ */
+function normalizeJson({ entry, errorFactory, label, value }) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    if (typeof value == "object")
+        return value;
+    if (typeof value == "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            throw errorFactory(entry.invalidJsonMessage ?? `${label} must be valid JSON.`, {
+                cause: /** @type {Error} */ (error),
+                code: `sync-${label}-invalid-json`
+            });
+        }
+    }
+    throw errorFactory(entry.invalidMessage ?? `${label} must be an object or JSON string.`, { code: `sync-${label}-invalid` });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-attribute-normalizer.js","sourceRoot":"","sources":["../../../src/sync/sync-attribute-normalizer.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {snakeCaseKey} from \"typanic\"\n\n/**\n * Builds the error thrown for a failed sync attribute validation.\n * @callback SyncAttributeErrorFactory\n * @param {string} message - Human-readable validation message.\n * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.\n * @returns {Error} Error to throw.\n */\n\n/**\n * Declarative validation schema for one writable sync attribute.\n *\n * Keys are camelCase attribute names; each attribute also accepts its\n * snake_case column key on input (the camelCase key wins when both are given)\n * and is written under the snake_case column key on output. Error messages\n * default to `<label> ...` phrasings with `sync-<label>-...` codes, where the\n * label defaults to the camelCase attribute name; apps pin exact messages per\n * attribute through the `*Message` overrides.\n * @typedef {object} SyncAttributeSchemaEntry\n * @property {\"date\" | \"json\" | \"raw\" | \"string\"} type - Attribute value type.\n * @property {boolean} [required] - Whether present blank/absent values are rejected (strings reject blank-after-trim, dates reject null).\n * @property {number} [maxLength] - Maximum string length, checked after trimming.\n * @property {string} [label] - Label used in derived messages and codes.\n * @property {string} [column] - Output column key. Defaults to the snake_cased attribute name.\n * @property {string} [requiredMessage] - Pinned message for required rejections.\n * @property {string} [tooLongMessage] - Pinned message for too-long rejections.\n * @property {string} [invalidMessage] - Pinned message for invalid dates and non-object/non-string json values.\n * @property {string} [invalidJsonMessage] - Pinned message for unparseable json strings.\n */\n\n/**\n * Normalizes writable sync attributes against a declarative schema.\n *\n * Only present keys are validated, so required attributes may be absent —\n * create defaults own that concern. Input keys not declared in the schema are\n * rejected by default so misspelled or read-only attributes fail loudly\n * instead of being silently discarded (`unknownAttributes: \"ignore\"` opts\n * out). Validation failures throw through the given error factory so apps\n * control the raised error class.\n * @param {object} args - Options.\n * @param {Record<string, ?>} args.attributes - Raw incoming attributes (camelCase and/or snake_case keys).\n * @param {SyncAttributeErrorFactory} args.errorFactory - Maps validation failures to thrown errors.\n * @param {Record<string, SyncAttributeSchemaEntry>} args.schema - Attribute schema keyed by camelCase attribute name.\n * @param {\"error\" | \"ignore\"} [args.unknownAttributes] - Unknown input-key handling. Defaults to \"error\".\n * @returns {Record<string, ?>} Normalized values keyed by snake_case column names.\n */\nexport default function normalizeAttributesWithSchema({attributes, errorFactory, schema, unknownAttributes = \"error\"}) {\n  if (!attributes || typeof attributes != \"object\") throw new Error(`normalizeAttributesWithSchema requires an attributes object, got: ${String(attributes)}`)\n  if (typeof errorFactory != \"function\") throw new Error(\"normalizeAttributesWithSchema requires an errorFactory function\")\n  if (!schema || typeof schema != \"object\") throw new Error(`normalizeAttributesWithSchema requires a schema object, got: ${String(schema)}`)\n  if (unknownAttributes != \"error\" && unknownAttributes != \"ignore\") {\n    throw new Error(`normalizeAttributesWithSchema unknownAttributes must be \"error\" or \"ignore\", got: ${String(unknownAttributes)}`)\n  }\n\n  /** @type {Record<string, ?>} */\n  const normalized = {}\n  /** @type {Set<string>} */\n  const knownInputKeys = new Set()\n\n  for (const [attributeName, entry] of Object.entries(schema)) {\n    const column = entry.column ?? snakeCaseKey(attributeName)\n    const inputKeys = column == attributeName ? [attributeName] : [column, attributeName]\n\n    for (const inputKey of inputKeys) {\n      knownInputKeys.add(inputKey)\n\n      if (!Object.prototype.hasOwnProperty.call(attributes, inputKey)) continue\n\n      normalized[column] = normalizeAttributeValue({attributeName, entry, errorFactory, value: attributes[inputKey]})\n    }\n  }\n\n  if (unknownAttributes == \"error\") {\n    for (const inputKey of Object.keys(attributes)) {\n      if (!knownInputKeys.has(inputKey)) {\n        throw errorFactory(`Unknown attribute: ${inputKey}.`, {code: \"sync-unknown-attribute\"})\n      }\n    }\n  }\n\n  return normalized\n}\n\n/**\n * Normalizes one present attribute value per its schema entry.\n * @param {object} args - Options.\n * @param {string} args.attributeName - camelCase attribute name.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {?} args.value - Raw value.\n * @returns {?} Normalized value.\n */\nfunction normalizeAttributeValue({attributeName, entry, errorFactory, value}) {\n  const label = entry.label ?? attributeName\n\n  if (entry.type == \"string\") return normalizeString({entry, errorFactory, label, value})\n  if (entry.type == \"date\") return normalizeDate({entry, errorFactory, label, value})\n  if (entry.type == \"json\") return normalizeJson({entry, errorFactory, label, value})\n  if (entry.type == \"raw\") return value\n\n  throw new Error(`Unknown sync attribute schema type for ${attributeName}: ${String(entry.type)}`)\n}\n\n/**\n * Normalizes a string attribute: trims, rejects blank required values after trimming, maps empty optional values to null and bounds the trimmed length.\n * @param {object} args - Options.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {string} args.label - Message/code label.\n * @param {?} args.value - Raw value.\n * @returns {string | null} Normalized string.\n */\nfunction normalizeString({entry, errorFactory, label, value}) {\n  const requiredError = () => errorFactory(entry.requiredMessage ?? `${label} is required.`, {code: `sync-${label}-required`})\n\n  if (value === null || value === undefined || value === \"\") {\n    if (entry.required) throw requiredError()\n\n    return null\n  }\n\n  const stringValue = String(value).trim()\n\n  if (stringValue === \"\") {\n    if (entry.required) throw requiredError()\n\n    return null\n  }\n\n  if (entry.maxLength !== undefined && stringValue.length > entry.maxLength) {\n    throw errorFactory(entry.tooLongMessage ?? `${label} is too long (maximum is ${entry.maxLength} characters).`, {code: `sync-${label}-too-long`})\n  }\n\n  return stringValue\n}\n\n/**\n * Normalizes a date attribute: Date instances pass through, strings/numbers are parsed and invalid or missing-required values are rejected.\n * @param {object} args - Options.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {string} args.label - Message/code label.\n * @param {?} args.value - Raw value.\n * @returns {Date | null} Normalized date.\n */\nfunction normalizeDate({entry, errorFactory, label, value}) {\n  if (!entry.required && (value === null || value === undefined || value === \"\")) return null\n\n  const dateValue = value instanceof Date ? value : typeof value == \"string\" || typeof value == \"number\" ? new Date(value) : null\n\n  if (!dateValue || Number.isNaN(dateValue.getTime())) {\n    throw errorFactory(entry.invalidMessage ?? `${label} must be a valid datetime.`, {code: `sync-${label}-invalid-datetime`})\n  }\n\n  return dateValue\n}\n\n/**\n * Normalizes a json attribute: empty values become null, objects pass through, strings must parse as JSON and other types are rejected.\n * @param {object} args - Options.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {string} args.label - Message/code label.\n * @param {?} args.value - Raw value.\n * @returns {?} Normalized json value.\n */\nfunction normalizeJson({entry, errorFactory, label, value}) {\n  if (value === null || value === undefined || value === \"\") return null\n  if (typeof value == \"object\") return value\n\n  if (typeof value == \"string\") {\n    try {\n      return JSON.parse(value)\n    } catch (error) {\n      throw errorFactory(entry.invalidJsonMessage ?? `${label} must be valid JSON.`, {\n        cause: /** @type {Error} */ (error),\n        code: `sync-${label}-invalid-json`\n      })\n    }\n  }\n\n  throw errorFactory(entry.invalidMessage ?? `${label} must be an object or JSON string.`, {code: `sync-${label}-invalid`})\n}\n"]}

package/build/src/sync/sync-resource-base.d.ts

@@ -14,6 +14,54 @@
  * @augments {FrontendModelBaseResource<TModelClass>}
  */
 export default class SyncResourceBase<TModelClass extends typeof import("../database/record/index.js").default = typeof import("../database/record/index.js").default> extends FrontendModelBaseResource<TModelClass> {
+    /**
+     * Declarative quick-search text columns. When declared, an index search on
+     * the pseudo-column `quickSearch` expands to an OR of LIKE conditions over
+     * these root-table columns instead of hitting the controller default.
+     * @type {string[] | null} */
+    static quickSearchColumns: string[] | null;
+    /**
+     * Declarative writable-attribute schema consumed by
+     * {@link SyncResourceBase#normalizeWritableAttributes}, keyed by camelCase
+     * attribute name.
+     * @type {Record<string, import("./sync-attribute-normalizer.js").SyncAttributeSchemaEntry> | null} */
+    static writableAttributes: Record<string, import("./sync-attribute-normalizer.js").SyncAttributeSchemaEntry> | null;
+    /**
+     * Expands a `quickSearch` pseudo-column search into an OR of LIKE conditions
+     * over the declared {@link SyncResourceBase.quickSearchColumns}.
+     * @param {object} args - Search args.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceAnyQuery} args.query - Query to filter.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceSearch} args.search - Search payload.
+     * @returns {boolean} Whether the search was handled as a quick search.
+     */
+    applyQuickSearch({ query, search }: {
+        query: import("../frontend-model-resource/base-resource.js").FrontendModelResourceAnyQuery;
+        search: import("../frontend-model-resource/base-resource.js").FrontendModelResourceSearch;
+    }): boolean;
+    /**
+     * Normalizes incoming writable attributes through the declared
+     * {@link SyncResourceBase.writableAttributes} schema: camelCase and
+     * snake_case input keys are accepted, values are validated per type and the
+     * normalized values are written under snake_case column keys. Validation
+     * failures throw client-safe errors built by
+     * {@link SyncResourceBase#writableAttributeError}.
+     * @param {Record<string, ?>} attributes - Raw incoming attributes.
+     * @param {{unknownAttributes?: "error" | "ignore"}} [options] - Unknown input-key handling. Defaults to "error".
+     * @returns {Record<string, ?>} Normalized attributes keyed by column names.
+     */
+    normalizeWritableAttributes(attributes: Record<string, unknown>, options?: {
+        unknownAttributes?: "error" | "ignore";
+    }): Record<string, unknown>;
+    /**
+     * Builds the client-safe error thrown for a failed writable-attribute validation.
+     * @param {string} message - Human-readable validation message.
+     * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.
+     * @returns {Error} Client-safe error.
+     */
+    writableAttributeError(message: string, { cause, code }: {
+        cause?: Error;
+        code: string;
+    }): Error;
     /**
      * Returns a stable change-feed page after app authorization.
      * @returns {Promise<Record<string, ?>>} Change-feed page result.

package/build/src/sync/sync-resource-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-resource-base.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,sCAHqE,WAAW,SAAnE,cAAe,6BAA6B,EAAE,OAAQ;IAIjE;;;OAGG;IACH,WAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAStC;IAED;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAQtC;IAED;;;;OAIG;IACH,qBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,sBAAsB,GAAG,IAAI,CAoBzC;IAED;;;;OAIG;IACH,qCAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D;QAAC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,CAQvD;IAED;;;OAGG;IACH,sBAFa,OAAO,mCAAmC,EAAE,OAAO,CAM/D;IAED;;;OAGG;IACH,qBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;OAGG;IACH,kBAFa,cAAc,6BAA6B,EAAE,OAAO,CAQhE;IAED;;;;OAIG;IACH,wBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAChI,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,cAAc,mCAAmC,EAAE,OAAO,CAItE;CACF;;;;;;;;gBApIa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;sCAPkB,6CAA6C"}
+{"version":3,"file":"sync-resource-base.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,sCAHqE,WAAW,SAAnE,cAAe,6BAA6B,EAAE,OAAQ;IAIjE;;;;iCAI6B;IAC7B,2BADU,MAAM,EAAE,GAAG,IAAI,CACO;IAEhC;;;;0GAIsG;IACtG,2BADU,MAAM,CAAC,MAAM,EAAE,OAAO,gCAAgC,EAAE,wBAAwB,CAAC,GAAG,IAAI,CAClE;IAgBhC;;;;;;;OAOG;IACH,oCAJG;QAAkG,KAAK,EAA/F,OAAO,6CAA6C,EAAE,6BAA6B;QACK,MAAM,EAA9F,OAAO,6CAA6C,EAAE,2BAA2B;KACzF,GAAU,OAAO,CA6BnB;IAED;;;;;;;;;;OAUG;IACH,wCAJW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,YACjB;QAAC,iBAAiB,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;KAAC,GACtC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAa7B;IAED;;;;;OAKG;IACH,gCAJW,MAAM,mBACN;QAAC,KAAK,CAAC,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAC3B,KAAK,CAIjB;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAStC;IAED;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAQtC;IAED;;;;OAIG;IACH,qBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,sBAAsB,GAAG,IAAI,CAoBzC;IAED;;;;OAIG;IACH,qCAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D;QAAC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,CAQvD;IAED;;;OAGG;IACH,sBAFa,OAAO,mCAAmC,EAAE,OAAO,CAM/D;IAED;;;OAGG;IACH,qBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;OAGG;IACH,kBAFa,cAAc,6BAA6B,EAAE,OAAO,CAQhE;IAED;;;;OAIG;IACH,wBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAChI,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,cAAc,mCAAmC,EAAE,OAAO,CAItE;CACF;;;;;;;;gBAvOa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;sCAXkB,6CAA6C"}

package/build/src/sync/sync-resource-base.js

@@ -1,7 +1,10 @@
 // @ts-check
 import { forcedNonBlankStringParam } from "typanic";
 import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js";
+import normalizeAttributesWithSchema from "./sync-attribute-normalizer.js";
 import SyncModelChangeFeedService from "./sync-model-change-feed-service.js";
+import VelociousError from "../velocious-error.js";
+const QUICK_SEARCH_COLUMN = "quickSearch";
 /**
  * Optional client-declared sync scope carried on a changes request.
  * @typedef {object} SerializedChangesScope
@@ -18,6 +21,91 @@ import SyncModelChangeFeedService from "./sync-model-change-feed-service.js";
  * @augments {FrontendModelBaseResource<TModelClass>}
  */
 export default class SyncResourceBase extends FrontendModelBaseResource {
+    /**
+     * Declarative quick-search text columns. When declared, an index search on
+     * the pseudo-column `quickSearch` expands to an OR of LIKE conditions over
+     * these root-table columns instead of hitting the controller default.
+     * @type {string[] | null} */
+    static quickSearchColumns = null;
+    /**
+     * Declarative writable-attribute schema consumed by
+     * {@link SyncResourceBase#normalizeWritableAttributes}, keyed by camelCase
+     * attribute name.
+     * @type {Record<string, import("./sync-attribute-normalizer.js").SyncAttributeSchemaEntry> | null} */
+    static writableAttributes = null;
+    /**
+     * Applies frontend-model index searches, expanding declared quick searches.
+     * @param {object} args - Search args.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceController} args.controller - Controller handling the query.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceAnyQuery} args.query - Query instance.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceSearch} args.search - Search params.
+     * @returns {void}
+     */
+    applyFrontendModelIndexSearch({ controller, query, search }) {
+        if (this.applyQuickSearch({ query, search }))
+            return;
+        super.applyFrontendModelIndexSearch({ controller, query, search });
+    }
+    /**
+     * Expands a `quickSearch` pseudo-column search into an OR of LIKE conditions
+     * over the declared {@link SyncResourceBase.quickSearchColumns}.
+     * @param {object} args - Search args.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceAnyQuery} args.query - Query to filter.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceSearch} args.search - Search payload.
+     * @returns {boolean} Whether the search was handled as a quick search.
+     */
+    applyQuickSearch({ query, search }) {
+        const quickSearchColumns = /** @type {typeof SyncResourceBase} */ (this.constructor).quickSearchColumns;
+        if (!quickSearchColumns || quickSearchColumns.length === 0)
+            return false;
+        if (search.path.length > 0 || search.column !== QUICK_SEARCH_COLUMN)
+            return false;
+        if (search.operator !== "like") {
+            throw VelociousError.safe("Sync quick search must use the like operator.", { code: "sync-invalid-quick-search" });
+        }
+        if (typeof search.value !== "string") {
+            throw VelociousError.safe("Sync quick search must be a string.", { code: "sync-invalid-quick-search" });
+        }
+        const trimmedValue = search.value.trim();
+        if (!trimmedValue)
+            return true;
+        const tableSql = query.driver.quoteTable(query.getTableReferenceForJoin());
+        const likeValue = `%${trimmedValue}%`;
+        const conditions = quickSearchColumns.map((columnName) => (`${tableSql}.${query.driver.quoteColumn(columnName)} LIKE ${query.driver.quote(likeValue)}`));
+        query.where(`(${conditions.join(" OR ")})`);
+        return true;
+    }
+    /**
+     * Normalizes incoming writable attributes through the declared
+     * {@link SyncResourceBase.writableAttributes} schema: camelCase and
+     * snake_case input keys are accepted, values are validated per type and the
+     * normalized values are written under snake_case column keys. Validation
+     * failures throw client-safe errors built by
+     * {@link SyncResourceBase#writableAttributeError}.
+     * @param {Record<string, ?>} attributes - Raw incoming attributes.
+     * @param {{unknownAttributes?: "error" | "ignore"}} [options] - Unknown input-key handling. Defaults to "error".
+     * @returns {Record<string, ?>} Normalized attributes keyed by column names.
+     */
+    normalizeWritableAttributes(attributes, options = {}) {
+        const schema = /** @type {typeof SyncResourceBase} */ (this.constructor).writableAttributes;
+        if (!schema)
+            throw new Error(`${this.constructor.name} must define static writableAttributes to use normalizeWritableAttributes`);
+        return normalizeAttributesWithSchema({
+            attributes,
+            errorFactory: (message, details) => this.writableAttributeError(message, details),
+            schema,
+            unknownAttributes: options.unknownAttributes
+        });
+    }
+    /**
+     * Builds the client-safe error thrown for a failed writable-attribute validation.
+     * @param {string} message - Human-readable validation message.
+     * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.
+     * @returns {Error} Client-safe error.
+     */
+    writableAttributeError(message, { cause, code }) {
+        return VelociousError.safe(message, cause ? { cause, code } : { code });
+    }
     /**
      * Returns a stable change-feed page after app authorization.
      * @returns {Promise<Record<string, ?>>} Change-feed page result.
@@ -119,4 +207,4 @@ export default class SyncResourceBase extends FrontendModelBaseResource {
         throw new Error("SyncResourceBase#replayServiceClass must be implemented");
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-resource-base.js","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {forcedNonBlankStringParam} from \"typanic\"\n\nimport FrontendModelBaseResource from \"../frontend-model-resource/base-resource.js\"\nimport SyncModelChangeFeedService from \"./sync-model-change-feed-service.js\"\n\n/**\n * Optional client-declared sync scope carried on a changes request.\n * @typedef {object} SerializedChangesScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the client query.\n * @property {string} resourceType - Client resource/model name the scope was declared for.\n */\n\n/**\n * Base resource for Velocious sync endpoints.\n *\n * Velocious owns the changes/replay orchestration (scope parsing, feed paging,\n * replay delegation, response shape) while apps subclass and only declare\n * authorization, feed scoping, and their replay service.\n * @template {typeof import(\"../database/record/index.js\").default} [TModelClass=typeof import(\"../database/record/index.js\").default]\n * @augments {FrontendModelBaseResource<TModelClass>}\n */\nexport default class SyncResourceBase extends FrontendModelBaseResource {\n  /**\n   * Returns a stable change-feed page after app authorization.\n   * @returns {Promise<Record<string, ?>>} Change-feed page result.\n   */\n  async changes() {\n    const params = this.params()\n    const scope = this.changesScope(params)\n\n    await this.authorizeChanges({params, scope})\n\n    return await this.changeFeedService({params, scope}).changes()\n  }\n\n  /**\n   * Replays client sync envelopes through the app replay service.\n   * @returns {Promise<Record<string, ?>>} Replay result with per-sync states.\n   */\n  async replay() {\n    const result = await this.buildReplayService().replay(this.params())\n\n    if (result.status === \"error\") return result\n\n    return {status: \"success\", syncs: result.syncs}\n  }\n\n  /**\n   * Parses the optional client-declared scope from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {SerializedChangesScope | null} Parsed scope, or null when the client sent none.\n   */\n  changesScope(params) {\n    const scope = params.scope\n\n    if (scope === undefined || scope === null) return null\n\n    if (typeof scope !== \"object\" || Array.isArray(scope)) {\n      throw new Error(`Sync changes scope must be an object, got: ${String(scope)}`)\n    }\n\n    const scopeParams = /** @type {Record<string, ?>} */ (scope)\n    const resourceType = forcedNonBlankStringParam(scopeParams, \"resourceType\")\n    const conditions = scopeParams.conditions\n\n    if (!conditions || typeof conditions !== \"object\" || Array.isArray(conditions)) {\n      throw new Error(`Sync changes scope.conditions must be an object, got: ${String(conditions)}`)\n    }\n\n    return {conditions: /** @type {Record<string, ?>} */ (conditions), resourceType}\n  }\n\n  /**\n   * Builds the change-feed service serving this changes request.\n   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} args - Request params and parsed scope.\n   * @returns {{changes: () => Promise<Record<string, ?>>}} Change-feed service.\n   */\n  changeFeedService({params, scope}) {\n    return new SyncModelChangeFeedService({\n      modelClass: this.syncModelClass(),\n      params,\n      scopeQuery: ({query}) => this.scopeChangesQuery({params, query, scope})\n    })\n  }\n\n  /**\n   * Builds the app replay service handling this replay request.\n   * @returns {import(\"./sync-envelope-replay-service.js\").default} Replay service instance.\n   */\n  buildReplayService() {\n    const ReplayServiceClass = this.replayServiceClass()\n\n    return new ReplayServiceClass(this.replayServiceArgs())\n  }\n\n  /**\n   * Returns constructor args for the app replay service.\n   * @returns {Record<string, ?>} Replay service constructor args.\n   */\n  replayServiceArgs() {\n    return {}\n  }\n\n  /**\n   * Returns the sync model class backing the change feed.\n   * @returns {typeof import(\"../database/record/index.js\").default} Sync model class.\n   */\n  syncModelClass() {\n    const modelClass = /** @type {typeof SyncResourceBase} */ (this.constructor).ModelClass\n\n    if (!modelClass) throw new Error(`${this.constructor.name} must define static ModelClass`)\n\n    return modelClass\n  }\n\n  /**\n   * Authorizes the current context for reading the requested changes.\n   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} _args - Request params and parsed scope.\n   * @returns {Promise<void>} Resolves when access is allowed; throws otherwise.\n   */\n  async authorizeChanges(_args) {\n    throw new Error(\"SyncResourceBase#authorizeChanges must be implemented\")\n  }\n\n  /**\n   * Applies app visibility scoping onto the change-feed query.\n   * @param {{params: Record<string, ?>, query: import(\"../database/query/model-class-query.js\").default, scope: SerializedChangesScope | null}} _args - Request params, feed query, and parsed scope.\n   * @returns {void}\n   */\n  scopeChangesQuery(_args) {\n    throw new Error(\"SyncResourceBase#scopeChangesQuery must be implemented\")\n  }\n\n  /**\n   * Returns the app replay service class handling replay mutations.\n   * @returns {typeof import(\"./sync-envelope-replay-service.js\").default} Replay service class.\n   */\n  replayServiceClass() {\n    throw new Error(\"SyncResourceBase#replayServiceClass must be implemented\")\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-resource-base.js","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {forcedNonBlankStringParam} from \"typanic\"\n\nimport FrontendModelBaseResource from \"../frontend-model-resource/base-resource.js\"\nimport normalizeAttributesWithSchema from \"./sync-attribute-normalizer.js\"\nimport SyncModelChangeFeedService from \"./sync-model-change-feed-service.js\"\nimport VelociousError from \"../velocious-error.js\"\n\nconst QUICK_SEARCH_COLUMN = \"quickSearch\"\n\n/**\n * Optional client-declared sync scope carried on a changes request.\n * @typedef {object} SerializedChangesScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the client query.\n * @property {string} resourceType - Client resource/model name the scope was declared for.\n */\n\n/**\n * Base resource for Velocious sync endpoints.\n *\n * Velocious owns the changes/replay orchestration (scope parsing, feed paging,\n * replay delegation, response shape) while apps subclass and only declare\n * authorization, feed scoping, and their replay service.\n * @template {typeof import(\"../database/record/index.js\").default} [TModelClass=typeof import(\"../database/record/index.js\").default]\n * @augments {FrontendModelBaseResource<TModelClass>}\n */\nexport default class SyncResourceBase extends FrontendModelBaseResource {\n  /**\n   * Declarative quick-search text columns. When declared, an index search on\n   * the pseudo-column `quickSearch` expands to an OR of LIKE conditions over\n   * these root-table columns instead of hitting the controller default.\n   * @type {string[] | null} */\n  static quickSearchColumns = null\n\n  /**\n   * Declarative writable-attribute schema consumed by\n   * {@link SyncResourceBase#normalizeWritableAttributes}, keyed by camelCase\n   * attribute name.\n   * @type {Record<string, import(\"./sync-attribute-normalizer.js\").SyncAttributeSchemaEntry> | null} */\n  static writableAttributes = null\n\n  /**\n   * Applies frontend-model index searches, expanding declared quick searches.\n   * @param {object} args - Search args.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceController} args.controller - Controller handling the query.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceAnyQuery} args.query - Query instance.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceSearch} args.search - Search params.\n   * @returns {void}\n   */\n  applyFrontendModelIndexSearch({controller, query, search}) {\n    if (this.applyQuickSearch({query, search})) return\n\n    super.applyFrontendModelIndexSearch({controller, query, search})\n  }\n\n  /**\n   * Expands a `quickSearch` pseudo-column search into an OR of LIKE conditions\n   * over the declared {@link SyncResourceBase.quickSearchColumns}.\n   * @param {object} args - Search args.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceAnyQuery} args.query - Query to filter.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceSearch} args.search - Search payload.\n   * @returns {boolean} Whether the search was handled as a quick search.\n   */\n  applyQuickSearch({query, search}) {\n    const quickSearchColumns = /** @type {typeof SyncResourceBase} */ (this.constructor).quickSearchColumns\n\n    if (!quickSearchColumns || quickSearchColumns.length === 0) return false\n    if (search.path.length > 0 || search.column !== QUICK_SEARCH_COLUMN) return false\n\n    if (search.operator !== \"like\") {\n      throw VelociousError.safe(\"Sync quick search must use the like operator.\", {code: \"sync-invalid-quick-search\"})\n    }\n\n    if (typeof search.value !== \"string\") {\n      throw VelociousError.safe(\"Sync quick search must be a string.\", {code: \"sync-invalid-quick-search\"})\n    }\n\n    const trimmedValue = search.value.trim()\n\n    if (!trimmedValue) return true\n\n    const tableSql = query.driver.quoteTable(query.getTableReferenceForJoin())\n    const likeValue = `%${trimmedValue}%`\n    const conditions = quickSearchColumns.map((columnName) => (\n      `${tableSql}.${query.driver.quoteColumn(columnName)} LIKE ${query.driver.quote(likeValue)}`\n    ))\n\n    query.where(`(${conditions.join(\" OR \")})`)\n\n    return true\n  }\n\n  /**\n   * Normalizes incoming writable attributes through the declared\n   * {@link SyncResourceBase.writableAttributes} schema: camelCase and\n   * snake_case input keys are accepted, values are validated per type and the\n   * normalized values are written under snake_case column keys. Validation\n   * failures throw client-safe errors built by\n   * {@link SyncResourceBase#writableAttributeError}.\n   * @param {Record<string, ?>} attributes - Raw incoming attributes.\n   * @param {{unknownAttributes?: \"error\" | \"ignore\"}} [options] - Unknown input-key handling. Defaults to \"error\".\n   * @returns {Record<string, ?>} Normalized attributes keyed by column names.\n   */\n  normalizeWritableAttributes(attributes, options = {}) {\n    const schema = /** @type {typeof SyncResourceBase} */ (this.constructor).writableAttributes\n\n    if (!schema) throw new Error(`${this.constructor.name} must define static writableAttributes to use normalizeWritableAttributes`)\n\n    return normalizeAttributesWithSchema({\n      attributes,\n      errorFactory: (message, details) => this.writableAttributeError(message, details),\n      schema,\n      unknownAttributes: options.unknownAttributes\n    })\n  }\n\n  /**\n   * Builds the client-safe error thrown for a failed writable-attribute validation.\n   * @param {string} message - Human-readable validation message.\n   * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.\n   * @returns {Error} Client-safe error.\n   */\n  writableAttributeError(message, {cause, code}) {\n    return VelociousError.safe(message, cause ? {cause, code} : {code})\n  }\n\n  /**\n   * Returns a stable change-feed page after app authorization.\n   * @returns {Promise<Record<string, ?>>} Change-feed page result.\n   */\n  async changes() {\n    const params = this.params()\n    const scope = this.changesScope(params)\n\n    await this.authorizeChanges({params, scope})\n\n    return await this.changeFeedService({params, scope}).changes()\n  }\n\n  /**\n   * Replays client sync envelopes through the app replay service.\n   * @returns {Promise<Record<string, ?>>} Replay result with per-sync states.\n   */\n  async replay() {\n    const result = await this.buildReplayService().replay(this.params())\n\n    if (result.status === \"error\") return result\n\n    return {status: \"success\", syncs: result.syncs}\n  }\n\n  /**\n   * Parses the optional client-declared scope from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {SerializedChangesScope | null} Parsed scope, or null when the client sent none.\n   */\n  changesScope(params) {\n    const scope = params.scope\n\n    if (scope === undefined || scope === null) return null\n\n    if (typeof scope !== \"object\" || Array.isArray(scope)) {\n      throw new Error(`Sync changes scope must be an object, got: ${String(scope)}`)\n    }\n\n    const scopeParams = /** @type {Record<string, ?>} */ (scope)\n    const resourceType = forcedNonBlankStringParam(scopeParams, \"resourceType\")\n    const conditions = scopeParams.conditions\n\n    if (!conditions || typeof conditions !== \"object\" || Array.isArray(conditions)) {\n      throw new Error(`Sync changes scope.conditions must be an object, got: ${String(conditions)}`)\n    }\n\n    return {conditions: /** @type {Record<string, ?>} */ (conditions), resourceType}\n  }\n\n  /**\n   * Builds the change-feed service serving this changes request.\n   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} args - Request params and parsed scope.\n   * @returns {{changes: () => Promise<Record<string, ?>>}} Change-feed service.\n   */\n  changeFeedService({params, scope}) {\n    return new SyncModelChangeFeedService({\n      modelClass: this.syncModelClass(),\n      params,\n      scopeQuery: ({query}) => this.scopeChangesQuery({params, query, scope})\n    })\n  }\n\n  /**\n   * Builds the app replay service handling this replay request.\n   * @returns {import(\"./sync-envelope-replay-service.js\").default} Replay service instance.\n   */\n  buildReplayService() {\n    const ReplayServiceClass = this.replayServiceClass()\n\n    return new ReplayServiceClass(this.replayServiceArgs())\n  }\n\n  /**\n   * Returns constructor args for the app replay service.\n   * @returns {Record<string, ?>} Replay service constructor args.\n   */\n  replayServiceArgs() {\n    return {}\n  }\n\n  /**\n   * Returns the sync model class backing the change feed.\n   * @returns {typeof import(\"../database/record/index.js\").default} Sync model class.\n   */\n  syncModelClass() {\n    const modelClass = /** @type {typeof SyncResourceBase} */ (this.constructor).ModelClass\n\n    if (!modelClass) throw new Error(`${this.constructor.name} must define static ModelClass`)\n\n    return modelClass\n  }\n\n  /**\n   * Authorizes the current context for reading the requested changes.\n   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} _args - Request params and parsed scope.\n   * @returns {Promise<void>} Resolves when access is allowed; throws otherwise.\n   */\n  async authorizeChanges(_args) {\n    throw new Error(\"SyncResourceBase#authorizeChanges must be implemented\")\n  }\n\n  /**\n   * Applies app visibility scoping onto the change-feed query.\n   * @param {{params: Record<string, ?>, query: import(\"../database/query/model-class-query.js\").default, scope: SerializedChangesScope | null}} _args - Request params, feed query, and parsed scope.\n   * @returns {void}\n   */\n  scopeChangesQuery(_args) {\n    throw new Error(\"SyncResourceBase#scopeChangesQuery must be implemented\")\n  }\n\n  /**\n   * Returns the app replay service class handling replay mutations.\n   * @returns {typeof import(\"./sync-envelope-replay-service.js\").default} Replay service class.\n   */\n  replayServiceClass() {\n    throw new Error(\"SyncResourceBase#replayServiceClass must be implemented\")\n  }\n}\n"]}