ghost 6.56.0 → 6.57.0

package/core/server/services/members-custom-fields/schema.js

@@ -1,21 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbCustomFieldValueWithField = exports.StoredCompositeValue = exports.DbCustomFieldValue = exports.DbCustomField = exports.FieldStatusSchema = exports.FIELD_STATUS = void 0;
+exports.DbCustomFieldLeaf = exports.DbCustomFieldValue = exports.DbCustomField = exports.FieldStatusSchema = exports.FIELD_STATUS = void 0;
 const zod_1 = require("zod");
 const custom_field_types_1 = require("@tryghost/custom-field-types");
 const db_date_1 = require("../../lib/db-date");
-// A field's lifecycle state. `archived` is a soft state: the field drops out of
-// the values path but stays visible in the definition list (with its status) so
-// admins can find, rename, restore, or permanently delete it. The values mirror
-// schema.js's `isIn` constraint on the column — which is static config and can't
-// import this, so that one stays literal with a pointer back here.
+// `archived` is soft: the field drops out of the values path but stays in the definition
+// list so it can be renamed, restored or deleted. Mirrors schema.js's `isIn` on the
+// column, which is static config and cannot import this.
 exports.FIELD_STATUS = { active: 'active', archived: 'archived' };
 exports.FieldStatusSchema = zod_1.z.enum([exports.FIELD_STATUS.active, exports.FIELD_STATUS.archived]);
-// The members_custom_fields row: the single source for the read projection and the
-// knex table type below. `type` is validated as the field-type enum here (the DB
-// only stores registered types), so the row already carries the narrow type and
-// the definition codec needs no cast. `status` travels with the row: it's part of
-// the read projection so the definition list can group active vs archived.
+// The single source for the read projection and the knex table type below. `type` parses
+// as the field-type enum, so the row carries the narrow type and no codec needs a cast.
 exports.DbCustomField = zod_1.z.object({
     id: zod_1.z.string(),
     key: zod_1.z.string(),
@@ -25,32 +20,28 @@ exports.DbCustomField = zod_1.z.object({
     created_at: db_date_1.DbDate,
     updated_at: db_date_1.DbDate.nullable()
 });
-// A member's stored value for one field. `value_text`/`value_json` are the raw
-// columns — which one carries the value, and how it decodes, is the storage
-// codec's business (see storage.ts), so they're plain nullable strings here.
+// One part of a member's value. What a `path` means is storage.ts's business, so the row
+// carries it as a plain string.
 exports.DbCustomFieldValue = zod_1.z.object({
     id: zod_1.z.string(),
     custom_field_id: zod_1.z.string(),
     member_id: zod_1.z.string(),
+    path: zod_1.z.string(),
+    // Nullable like the column, though nothing here writes a null: a part with no value
+    // has no row.
     value_text: zod_1.z.string().nullable(),
-    value_json: zod_1.z.string().nullable(),
     created_at: db_date_1.DbDate,
     updated_at: db_date_1.DbDate.nullable()
 });
-// A composite value once decoded: sub-field keys to values, and no narrower. Which
-// sub-fields a composite has is its field type's business, not the row's.
+// The field's key travels with the row so a value assembles without a second lookup.
 //
-// It doubles as the guard on a stored blob. A JSON column can just as easily hold an
-// array, a null or a bare number, and a record rejects all three — so parsing against
-// this is what narrows the type, with no assertion needed.
-exports.StoredCompositeValue = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
-// The value join a read needs: the field's identity and type travel with the
-// stored columns, so a row can be decoded without a second lookup. `type` is
-// parsed as the field-type enum, which narrows it with no cast.
-exports.DbCustomFieldValueWithField = zod_1.z.object({
+// `type` takes no part in the assembly and is here as a gate: a value whose type has left
+// the catalog is one the definitions list no longer returns either, so failing to parse
+// is what drops it.
+exports.DbCustomFieldLeaf = zod_1.z.object({
     member_id: zod_1.z.string(),
     key: zod_1.z.string(),
     type: custom_field_types_1.FieldTypeSchema,
-    value_text: zod_1.z.string().nullable(),
-    value_json: zod_1.z.string().nullable()
+    path: zod_1.z.string(),
+    value_text: zod_1.z.string()
 });

package/core/server/services/members-custom-fields/schema.ts

@@ -3,20 +3,15 @@ import type {Knex} from 'knex';
 import {FieldTypeSchema} from '@tryghost/custom-field-types';
 import {DbDate} from '../../lib/db-date';
 
-// A field's lifecycle state. `archived` is a soft state: the field drops out of
-// the values path but stays visible in the definition list (with its status) so
-// admins can find, rename, restore, or permanently delete it. The values mirror
-// schema.js's `isIn` constraint on the column — which is static config and can't
-// import this, so that one stays literal with a pointer back here.
+// `archived` is soft: the field drops out of the values path but stays in the definition
+// list so it can be renamed, restored or deleted. Mirrors schema.js's `isIn` on the
+// column, which is static config and cannot import this.
 export const FIELD_STATUS = {active: 'active', archived: 'archived'} as const;
 export type FieldStatus = typeof FIELD_STATUS[keyof typeof FIELD_STATUS];
 export const FieldStatusSchema = z.enum([FIELD_STATUS.active, FIELD_STATUS.archived]);
 
-// The members_custom_fields row: the single source for the read projection and the
-// knex table type below. `type` is validated as the field-type enum here (the DB
-// only stores registered types), so the row already carries the narrow type and
-// the definition codec needs no cast. `status` travels with the row: it's part of
-// the read projection so the definition list can group active vs archived.
+// The single source for the read projection and the knex table type below. `type` parses
+// as the field-type enum, so the row carries the narrow type and no codec needs a cast.
 export const DbCustomField = z.object({
     id: z.string(),
     key: z.string(),
@@ -29,38 +24,33 @@ export const DbCustomField = z.object({
 
 type CustomFieldRow = z.infer<typeof DbCustomField>;
 
-// A member's stored value for one field. `value_text`/`value_json` are the raw
-// columns — which one carries the value, and how it decodes, is the storage
-// codec's business (see storage.ts), so they're plain nullable strings here.
+// One part of a member's value. What a `path` means is storage.ts's business, so the row
+// carries it as a plain string.
 export const DbCustomFieldValue = z.object({
     id: z.string(),
     custom_field_id: z.string(),
     member_id: z.string(),
+    path: z.string(),
+    // Nullable like the column, though nothing here writes a null: a part with no value
+    // has no row.
     value_text: z.string().nullable(),
-    value_json: z.string().nullable(),
     created_at: DbDate,
     updated_at: DbDate.nullable()
 });
 
 type CustomFieldValueRow = z.infer<typeof DbCustomFieldValue>;
 
-// A composite value once decoded: sub-field keys to values, and no narrower. Which
-// sub-fields a composite has is its field type's business, not the row's.
+// The field's key travels with the row so a value assembles without a second lookup.
 //
-// It doubles as the guard on a stored blob. A JSON column can just as easily hold an
-// array, a null or a bare number, and a record rejects all three — so parsing against
-// this is what narrows the type, with no assertion needed.
-export const StoredCompositeValue = z.record(z.string(), z.unknown());
-
-// The value join a read needs: the field's identity and type travel with the
-// stored columns, so a row can be decoded without a second lookup. `type` is
-// parsed as the field-type enum, which narrows it with no cast.
-export const DbCustomFieldValueWithField = z.object({
+// `type` takes no part in the assembly and is here as a gate: a value whose type has left
+// the catalog is one the definitions list no longer returns either, so failing to parse
+// is what drops it.
+export const DbCustomFieldLeaf = z.object({
     member_id: z.string(),
     key: z.string(),
     type: FieldTypeSchema,
-    value_text: z.string().nullable(),
-    value_json: z.string().nullable()
+    path: z.string(),
+    value_text: z.string()
 });
 
 declare module 'knex/types/tables' {

package/core/server/services/members-custom-fields/storage.js

@@ -1,35 +1,102 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.storageCodecFor = storageCodecFor;
-exports.storageColumnsFor = storageColumnsFor;
-const custom_field_types_1 = require("@tryghost/custom-field-types");
-const STORAGE_CODECS = {
-    // The value is already a string by the time it gets here — the field type's
-    // schema validated it — so encoding is identity.
-    text: {
-        column: 'value_text',
-        encode: value => String(value),
-        decode: stored => stored
-    },
-    json: {
-        column: 'value_json',
-        encode: value => JSON.stringify(value),
-        decode: stored => JSON.parse(stored)
-    }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-function storageCodecFor(type) {
-    return STORAGE_CODECS[custom_field_types_1.FIELD_TYPES[type].storageType];
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_PATH = void 0;
+exports.leavesFor = leavesFor;
+exports.leavesToWrite = leavesToWrite;
+exports.valueFromLeaves = valueFromLeaves;
+exports.valuesFromLeaves = valuesFromLeaves;
+const errors_1 = __importDefault(require("@tryghost/errors"));
+// A value is a tree; the database stores one row per leaf, under the path addressing it.
+// A value with no parts is a single leaf at the root, a part is a leaf under its key, and
+// a nested part is addressed with a dotted path.
+//
+// Nothing here may consult a field type. Values arrive already parsed against their own,
+// and rows are rebuilt as what they were written as rather than as what the type says
+// today, so a type that changes shape does not rewrite what members already have.
+/** Also the notation a segment filter addresses a part by, so the two cannot drift. */
+const SEPARATOR = '.';
+/** Empty rather than null: a unique index does not constrain nulls, which would let the same leaf be stored twice. */
+exports.ROOT_PATH = '';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /**
- * The value columns for a row, with the one this field type doesn't use
- * explicitly nulled — the "exactly one column populated" invariant is written
- * out on every insert and update rather than left to convention.
+ * Values are rebuilt into plain objects, so a segment naming something every object
+ * already has would reach the prototype instead of the value — and a write through
+ * `__proto__` reaches every object in the process. Paths come out of the database, so
+ * this holds here rather than trusting whatever put them there.
  */
-function storageColumnsFor(type, value) {
-    const codec = storageCodecFor(type);
+function isSafeSegment(segment) {
+    return !(segment in Object.prototype);
+}
+/** Every leaf a value names, at any depth, including the ones it names as empty. */
+function leavesFor(value, path = exports.ROOT_PATH) {
+    if (typeof value === 'string') {
+        return [{ path, value_text: value }];
+    }
+    // Thrown rather than stored: the read path rejects a non-string row, so writing one
+    // loses the value with nothing to say it ever arrived.
+    if (!isRecord(value)) {
+        throw new errors_1.default.IncorrectUsageError({
+            message: `A custom field value must be a string or a record of them, not ${value === null ? 'null' : typeof value}.`
+        });
+    }
+    // Undefined means the value does not name the part, which is not the same as naming
+    // it empty: the first leaves what is stored alone, the second clears it.
+    return Object.entries(value)
+        .filter(([, part]) => part !== undefined)
+        .flatMap(([key, part]) => leavesFor(part, path === exports.ROOT_PATH ? key : `${path}${SEPARATOR}${key}`));
+}
+/** A value split into the leaves it sets and the paths it clears. */
+function leavesToWrite(value) {
+    const named = leavesFor(value);
     return {
-        value_text: null,
-        value_json: null,
-        [codec.column]: codec.encode(value)
+        set: named.filter(leaf => leaf.value_text !== ''),
+        cleared: named.filter(leaf => leaf.value_text === '').map(leaf => leaf.path)
     };
 }
+/** The value a set of leaves adds up to, rebuilt to whatever depth their paths describe. */
+function valueFromLeaves(leaves) {
+    const root = leaves.find(leaf => leaf.path === exports.ROOT_PATH);
+    if (root) {
+        return root.value_text;
+    }
+    const value = {};
+    for (const leaf of leaves) {
+        const segments = leaf.path.split(SEPARATOR);
+        if (!segments.every(isSafeSegment)) {
+            continue;
+        }
+        const last = segments.pop();
+        // A segment already holding a string is replaced rather than descended into: this
+        // runs over every member of a list response, so a contradictory pair of paths
+        // should cost one odd value rather than the whole response.
+        const parent = segments.reduce((target, segment) => {
+            if (!isRecord(target[segment])) {
+                target[segment] = {};
+            }
+            return target[segment];
+        }, value);
+        parent[last] = leaf.value_text;
+    }
+    return value;
+}
+/** Every member's values, keyed by member and then field key; a member with no rows is absent. */
+function valuesFromLeaves(leaves) {
+    const byMemberAndField = new Map();
+    for (const { member_id: memberId, key, path, value_text: valueText } of leaves) {
+        const fields = byMemberAndField.get(memberId) ?? new Map();
+        const forField = fields.get(key) ?? [];
+        forField.push({ path, value_text: valueText });
+        fields.set(key, forField);
+        byMemberAndField.set(memberId, fields);
+    }
+    const byMember = new Map();
+    for (const [memberId, fields] of byMemberAndField) {
+        byMember.set(memberId, Object.fromEntries([...fields].map(([key, forField]) => [key, valueFromLeaves(forField)])));
+    }
+    return byMember;
+}

package/core/server/services/members-custom-fields/storage.ts

@@ -1,47 +1,122 @@
-import {FIELD_TYPES, type FieldType, type StorageType} from '@tryghost/custom-field-types';
-
-// The backend half of the storage-type contract: the catalog says which storage
-// type a field type routes to, and this says what that means in the database —
-// the column, and how a value crosses the boundary. Adding a field type that
-// reuses an existing storage type needs nothing here.
-
-export type ValueColumn = 'value_text' | 'value_json';
-
-interface StorageCodec {
-    column: ValueColumn;
-    encode(value: unknown): string;
-    decode(stored: string): unknown;
-}
-
-const STORAGE_CODECS = {
-    // The value is already a string by the time it gets here — the field type's
-    // schema validated it — so encoding is identity.
-    text: {
-        column: 'value_text',
-        encode: value => String(value),
-        decode: stored => stored
-    },
-    json: {
-        column: 'value_json',
-        encode: value => JSON.stringify(value),
-        decode: stored => JSON.parse(stored)
-    }
-} as const satisfies Record<StorageType, StorageCodec>;
+import errors from '@tryghost/errors';
+
+// A value is a tree; the database stores one row per leaf, under the path addressing it.
+// A value with no parts is a single leaf at the root, a part is a leaf under its key, and
+// a nested part is addressed with a dotted path.
+//
+// Nothing here may consult a field type. Values arrive already parsed against their own,
+// and rows are rebuilt as what they were written as rather than as what the type says
+// today, so a type that changes shape does not rewrite what members already have.
+
+/** Also the notation a segment filter addresses a part by, so the two cannot drift. */
+const SEPARATOR = '.';
+
+/** Empty rather than null: a unique index does not constrain nulls, which would let the same leaf be stored twice. */
+export const ROOT_PATH = '';
+
+export interface Leaf {
+    path: string;
+    value_text: string;
+}
+
+export interface StoredLeaf extends Leaf {
+    member_id: string;
+    key: string;
+}
 
-export function storageCodecFor(type: FieldType): StorageCodec {
-    return STORAGE_CODECS[FIELD_TYPES[type].storageType];
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
 /**
- * The value columns for a row, with the one this field type doesn't use
- * explicitly nulled — the "exactly one column populated" invariant is written
- * out on every insert and update rather than left to convention.
+ * Values are rebuilt into plain objects, so a segment naming something every object
+ * already has would reach the prototype instead of the value — and a write through
+ * `__proto__` reaches every object in the process. Paths come out of the database, so
+ * this holds here rather than trusting whatever put them there.
  */
-export function storageColumnsFor(type: FieldType, value: unknown): Record<ValueColumn, string | null> {
-    const codec = storageCodecFor(type);
+function isSafeSegment(segment: string): boolean {
+    return !(segment in Object.prototype);
+}
+
+/** Every leaf a value names, at any depth, including the ones it names as empty. */
+export function leavesFor(value: unknown, path: string = ROOT_PATH): Leaf[] {
+    if (typeof value === 'string') {
+        return [{path, value_text: value}];
+    }
+
+    // Thrown rather than stored: the read path rejects a non-string row, so writing one
+    // loses the value with nothing to say it ever arrived.
+    if (!isRecord(value)) {
+        throw new errors.IncorrectUsageError({
+            message: `A custom field value must be a string or a record of them, not ${value === null ? 'null' : typeof value}.`
+        });
+    }
+
+    // Undefined means the value does not name the part, which is not the same as naming
+    // it empty: the first leaves what is stored alone, the second clears it.
+    return Object.entries(value)
+        .filter(([, part]) => part !== undefined)
+        .flatMap(([key, part]) => leavesFor(part, path === ROOT_PATH ? key : `${path}${SEPARATOR}${key}`));
+}
+
+/** A value split into the leaves it sets and the paths it clears. */
+export function leavesToWrite(value: unknown): {set: Leaf[], cleared: string[]} {
+    const named = leavesFor(value);
+
     return {
-        value_text: null,
-        value_json: null,
-        [codec.column]: codec.encode(value)
+        set: named.filter(leaf => leaf.value_text !== ''),
+        cleared: named.filter(leaf => leaf.value_text === '').map(leaf => leaf.path)
     };
 }
+
+/** The value a set of leaves adds up to, rebuilt to whatever depth their paths describe. */
+export function valueFromLeaves(leaves: readonly Leaf[]): unknown {
+    const root = leaves.find(leaf => leaf.path === ROOT_PATH);
+    if (root) {
+        return root.value_text;
+    }
+
+    const value: Record<string, unknown> = {};
+    for (const leaf of leaves) {
+        const segments = leaf.path.split(SEPARATOR);
+        if (!segments.every(isSafeSegment)) {
+            continue;
+        }
+
+        const last = segments.pop() as string;
+        // A segment already holding a string is replaced rather than descended into: this
+        // runs over every member of a list response, so a contradictory pair of paths
+        // should cost one odd value rather than the whole response.
+        const parent = segments.reduce<Record<string, unknown>>((target, segment) => {
+            if (!isRecord(target[segment])) {
+                target[segment] = {};
+            }
+            return target[segment] as Record<string, unknown>;
+        }, value);
+        parent[last] = leaf.value_text;
+    }
+
+    return value;
+}
+
+/** Every member's values, keyed by member and then field key; a member with no rows is absent. */
+export function valuesFromLeaves(leaves: readonly StoredLeaf[]): Map<string, Record<string, unknown>> {
+    const byMemberAndField = new Map<string, Map<string, Leaf[]>>();
+
+    for (const {member_id: memberId, key, path, value_text: valueText} of leaves) {
+        const fields = byMemberAndField.get(memberId) ?? new Map<string, Leaf[]>();
+        const forField = fields.get(key) ?? [];
+        forField.push({path, value_text: valueText});
+        fields.set(key, forField);
+        byMemberAndField.set(memberId, fields);
+    }
+
+    const byMember = new Map<string, Record<string, unknown>>();
+    for (const [memberId, fields] of byMemberAndField) {
+        byMember.set(memberId, Object.fromEntries(
+            [...fields].map(([key, forField]) => [key, valueFromLeaves(forField)])
+        ));
+    }
+
+    return byMember;
+}