ghost 6.61.0 → 6.63.0

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

@@ -1,199 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CUSTOM_FIELDS_RELATION = void 0;
-exports.createCustomFieldsFilterTransformer = createCustomFieldsFilterTransformer;
-// The members filter reaches custom field values through a `custom_fields` relation
-// on the Member model (the values table joined on member_id). A field is named by its
-// `key` — the stable public slug — and matched on its `value`; a composite field's
-// part is named as `value.<part>`, and a part's presence as `path.<part>`:
-//
-//   (custom_fields.key:'company'+custom_fields.value:'Ghost')               // value
-//   (custom_fields.key:'shipping_address'+custom_fields.value.country:'GB')
-//   custom_fields.key:'phone'  /  custom_fields.key:-'phone'                // field set / not set
-//   (custom_fields.key:'shipping_address'+custom_fields.path:'country')     // part set
-//   (custom_fields.key:'shipping_address'+custom_fields.path:-'country')    // part not set
-//
-// The values table stores one row per leaf: `custom_field_key` (the field's stable key),
-// `path` (empty for a scalar, the part's key for a composite), and `value_text`. A scalar
-// field is just a leaf at path ''; "the field", "a part", and "the whole field" are the
-// same thing — a set of leaf rows pinned by (custom_field_key, [path], [value]). So every
-// filter is one `$elemMatch` over those columns: positive asserts a matching leaf exists,
-// `$not` asserts none does. The public grammar is the storage vocabulary here — the key
-// sits on the row — so the transformer emits it straight, with no id lookup and no field
-// catalog read. That is what lets the Member model chain it inline on every members query,
-// rather than each call site remembering to wire it. A key that names no current field
-// matches no leaf; the admin never offers an archived or deleted field in the filter UI,
-// though the API leaves them queryable.
-const errors_1 = __importDefault(require("@tryghost/errors"));
-const RELATION = 'custom_fields';
-const PREFIX = `${RELATION}.`;
-const KEY_ATTRIBUTE = `${PREFIX}key`;
-const VALUE_ATTRIBUTE = `${PREFIX}value`;
-const PATH_ATTRIBUTE = `${PREFIX}path`;
-const ROOT_PATH = '';
-// Only recurse into plain objects/arrays; a RegExp, Date, etc. is a leaf value that
-// must pass through by reference (recursing would strip a regex to `{}`).
-function isPlainObject(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value) &&
-        (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
-}
-// A single-clause object whose one key targets the custom_fields relation.
-function isCustomFieldClause(node) {
-    if (!isPlainObject(node)) {
-        return false;
-    }
-    const keys = Object.keys(node);
-    return keys.length === 1 && keys[0].startsWith(PREFIX);
-}
-// A grouped compound: an $and whose clauses all target the relation and name exactly one
-// `key`. Its clauses describe one leaf row.
-//
-// Exactly one, not at least one: two whole-field filters ANDed together arrive as a flat
-// `key:'a'+key:'b'`, since a bare key clause needs no group of its own. That is two
-// filters — a member with a value for both — not one leaf that is somehow both fields, so
-// it has to fall through and be transformed a clause at a time.
-function isCustomFieldCompound(clauses) {
-    if (!Array.isArray(clauses) || clauses.length < 2 || !clauses.every(isCustomFieldClause)) {
-        return false;
-    }
-    return clauses.filter((clause) => Object.keys(clause)[0] === KEY_ATTRIBUTE).length === 1;
-}
-// `custom_fields.value` addresses the scalar (root) leaf; `custom_fields.value.<part>`
-// a composite's part. Returns the row `path` the attribute selects, or null if the
-// attribute isn't a value clause.
-function pathForValueAttribute(attribute) {
-    if (attribute === VALUE_ATTRIBUTE) {
-        return ROOT_PATH;
-    }
-    if (attribute.startsWith(`${VALUE_ATTRIBUTE}.`)) {
-        return attribute.slice(`${VALUE_ATTRIBUTE}.`.length);
-    }
-    return null;
-}
-// The single `{$ne}` shape all negations arrive as (is-not-set on a key or part).
-function negatedString(value) {
-    return isPlainObject(value) && typeof value.$ne === 'string' ? value.$ne : null;
-}
-function createCustomFieldsFilterTransformer() {
-    // The grammar carries the field key in the clause value; take it as a string,
-    // defaulting to one no field can hold so a malformed clause matches nothing.
-    const keyOf = (value) => (typeof value === 'string' ? value : '');
-    // One (maybe-negated) $elemMatch over the leaf columns: positive is "a leaf pinned
-    // by these matches", `$not` is "no leaf does".
-    function buildElemMatch(fieldKey, conditions, negate) {
-        const match = { custom_field_key: fieldKey, ...conditions };
-        if (negate) {
-            return { [RELATION]: { $not: { $elemMatch: match } } };
-        }
-        return { [RELATION]: { $elemMatch: match } };
-    }
-    // A `(key + value[.part] | path)` compound. A `value` clause pins the part and its
-    // value; a `path` clause pins the part's presence (no value), and a negated path is
-    // is-not-set — no such leaf — which negates the whole match.
-    function toElemMatch(clauses) {
-        let fieldKey = '';
-        let hasKey = false;
-        let hasLeaf = false;
-        const conditions = {};
-        let negate = false;
-        const oneLeafOnly = () => {
-            if (hasLeaf) {
-                throw new errors_1.default.BadRequestError({
-                    message: 'A custom field filter takes one value or path clause.',
-                });
-            }
-            hasLeaf = true;
-        };
-        for (const clause of clauses) {
-            const [attribute, value] = Object.entries(clause)[0];
-            if (attribute === KEY_ATTRIBUTE) {
-                if (hasKey) {
-                    throw new errors_1.default.BadRequestError({
-                        message: `A custom field filter takes one "${KEY_ATTRIBUTE}" clause.`,
-                    });
-                }
-                hasKey = true;
-                fieldKey = keyOf(value);
-            }
-            else if (attribute === PATH_ATTRIBUTE) {
-                oneLeafOnly();
-                const negatedPath = negatedString(value);
-                conditions.path = negatedPath ?? value;
-                negate = negatedPath !== null;
-            }
-            else {
-                const path = pathForValueAttribute(attribute);
-                if (path === null) {
-                    // Not the key, a value/value.<part>, or a path: it names no leaf
-                    // column, so dropping it would silently widen the match to the key
-                    // alone. Fail closed instead.
-                    throw new errors_1.default.BadRequestError({
-                        message: `Unsupported custom field filter clause "${attribute}".`,
-                    });
-                }
-                oneLeafOnly();
-                conditions.path = path;
-                conditions.value_text = value;
-            }
-        }
-        return buildElemMatch(fieldKey, conditions, negate);
-    }
-    // A standalone `key` clause is whole-field is-set / is-not-set: a leaf for this
-    // field exists (any part), or none does.
-    function fromKeyClause(value) {
-        const negatedKey = negatedString(value);
-        if (negatedKey !== null) {
-            return buildElemMatch(keyOf(negatedKey), {}, true);
-        }
-        return buildElemMatch(keyOf(value), {}, false);
-    }
-    function transform(node) {
-        if (Array.isArray(node)) {
-            return node.map(transform);
-        }
-        if (!isPlainObject(node)) {
-            return node;
-        }
-        if (isCustomFieldCompound(node.$and)) {
-            return toElemMatch(node.$and);
-        }
-        const out = {};
-        for (const [key, value] of Object.entries(node)) {
-            if (key === KEY_ATTRIBUTE) {
-                Object.assign(out, fromKeyClause(value));
-            }
-            else if (key.startsWith(PREFIX)) {
-                // A value or path clause only means something paired with its key in one
-                // leaf, which arrives as the compound handled above. A `custom_fields.*`
-                // clause reaching here is unpaired (or its pair was not grouped), so fail
-                // closed rather than pass it to mongo-knex as a column that does not exist.
-                throw new errors_1.default.BadRequestError({
-                    message: `A "${key}" filter must be grouped with its "${KEY_ATTRIBUTE}" clause, for example (${KEY_ATTRIBUTE}:'a_field'+${VALUE_ATTRIBUTE}:'a value').`,
-                });
-            }
-            else {
-                out[key] = transform(value);
-            }
-        }
-        return out;
-    }
-    return (query) => transform(query);
-}
-/**
- * The Member filter relation that exposes custom field values. A member has many leaf
- * rows (one per field, or per part of a composite field), and a predicate asks whether
- * one of them matches, so this joins the values table on member_id and mongo-knex emits
- * it as a correlated `members.id IN (…)` subquery — composing with every other member
- * filter. Registered only behind the `membersCustomFields` flag.
- */
-exports.CUSTOM_FIELDS_RELATION = {
-    tableName: 'members_custom_field_values',
-    tableNameAs: RELATION,
-    type: 'oneToOne',
-    joinFrom: 'member_id',
-};

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

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCustomFieldsResponse = void 0;
-const zod_1 = require("zod");
-const case_keys_1 = require("../../lib/case-keys");
-const models_1 = require("./models");
-// Response schema — the field-definition shape the admin endpoints emit. `id` is
-// the DB primary key and deliberately never leaves the API; a field is addressed
-// by its immutable `key`. The `.pipe` below strips id from the mapped output.
-const CustomFieldResource = zod_1.z.object({
-    key: zod_1.z.string(),
-    name: zod_1.z.string(),
-    type: zod_1.z.string(),
-    status: zod_1.z.string(),
-    created_at: zod_1.z.date(),
-    updated_at: zod_1.z.date().nullable(),
-});
-const CustomFieldsResponse = zod_1.z.object({ members_custom_fields: zod_1.z.array(CustomFieldResource) });
-exports.toCustomFieldsResponse = zod_1.z
-    .array(models_1.CustomField)
-    .transform((fields) => ({
-    members_custom_fields: fields.map((field) => (0, case_keys_1.snakeKeys)(field)),
-}))
-    .pipe(CustomFieldsResponse);

package/core/server/services/stripe/services/checkout/allowed-countries.js

@@ -1,267 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRIPE_ALLOWED_COUNTRIES = void 0;
-exports.isStripeAllowedCountry = isStripeAllowedCountry;
-/**
- * The countries Stripe Checkout will accept in `shipping_address_collection`.
- *
- * Not a general list of countries. This is not a question about which places exist, it is
- * a question about where this payment processor will ship, and only the processor's answer
- * decides whether a session can be created at all. A general ISO list gets it wrong in both
- * directions: it omits places Stripe accepts, and it includes the sanctioned countries
- * Stripe refuses.
- *
- * Measured against the live API at the pinned version by `e2e/scripts/probe-stripe-constraints.ts`,
- * not read from the SDK's `AllowedCountry` union, because that union is wrong: it omits
- * `SD`, which the live API accepts. Every other code the union carries was confirmed
- * accepted, so the union is a subset of this list rather than a different one — which is
- * what the accompanying test holds it to, so a country Stripe adds cannot pass unnoticed.
- *
- * A code Stripe rejects fails the whole session create, which is a publisher who cannot
- * sell. So this is checked when a publisher chooses a country rather than when a member
- * tries to buy.
- */
-exports.STRIPE_ALLOWED_COUNTRIES = [
-    'AC',
-    'AD',
-    'AE',
-    'AF',
-    'AG',
-    'AI',
-    'AL',
-    'AM',
-    'AO',
-    'AQ',
-    'AR',
-    'AT',
-    'AU',
-    'AW',
-    'AX',
-    'AZ',
-    'BA',
-    'BB',
-    'BD',
-    'BE',
-    'BF',
-    'BG',
-    'BH',
-    'BI',
-    'BJ',
-    'BL',
-    'BM',
-    'BN',
-    'BO',
-    'BQ',
-    'BR',
-    'BS',
-    'BT',
-    'BV',
-    'BW',
-    'BY',
-    'BZ',
-    'CA',
-    'CD',
-    'CF',
-    'CG',
-    'CH',
-    'CI',
-    'CK',
-    'CL',
-    'CM',
-    'CN',
-    'CO',
-    'CR',
-    'CV',
-    'CW',
-    'CY',
-    'CZ',
-    'DE',
-    'DJ',
-    'DK',
-    'DM',
-    'DO',
-    'DZ',
-    'EC',
-    'EE',
-    'EG',
-    'EH',
-    'ER',
-    'ES',
-    'ET',
-    'FI',
-    'FJ',
-    'FK',
-    'FO',
-    'FR',
-    'GA',
-    'GB',
-    'GD',
-    'GE',
-    'GF',
-    'GG',
-    'GH',
-    'GI',
-    'GL',
-    'GM',
-    'GN',
-    'GP',
-    'GQ',
-    'GR',
-    'GS',
-    'GT',
-    'GU',
-    'GW',
-    'GY',
-    'HK',
-    'HN',
-    'HR',
-    'HT',
-    'HU',
-    'ID',
-    'IE',
-    'IL',
-    'IM',
-    'IN',
-    'IO',
-    'IQ',
-    'IS',
-    'IT',
-    'JE',
-    'JM',
-    'JO',
-    'JP',
-    'KE',
-    'KG',
-    'KH',
-    'KI',
-    'KM',
-    'KN',
-    'KR',
-    'KW',
-    'KY',
-    'KZ',
-    'LA',
-    'LB',
-    'LC',
-    'LI',
-    'LK',
-    'LR',
-    'LS',
-    'LT',
-    'LU',
-    'LV',
-    'LY',
-    'MA',
-    'MC',
-    'MD',
-    'ME',
-    'MF',
-    'MG',
-    'MK',
-    'ML',
-    'MM',
-    'MN',
-    'MO',
-    'MQ',
-    'MR',
-    'MS',
-    'MT',
-    'MU',
-    'MV',
-    'MW',
-    'MX',
-    'MY',
-    'MZ',
-    'NA',
-    'NC',
-    'NE',
-    'NG',
-    'NI',
-    'NL',
-    'NO',
-    'NP',
-    'NR',
-    'NU',
-    'NZ',
-    'OM',
-    'PA',
-    'PE',
-    'PF',
-    'PG',
-    'PH',
-    'PK',
-    'PL',
-    'PM',
-    'PN',
-    'PR',
-    'PS',
-    'PT',
-    'PY',
-    'QA',
-    'RE',
-    'RO',
-    'RS',
-    'RU',
-    'RW',
-    'SA',
-    'SB',
-    'SC',
-    'SD',
-    'SE',
-    'SG',
-    'SH',
-    'SI',
-    'SJ',
-    'SK',
-    'SL',
-    'SM',
-    'SN',
-    'SO',
-    'SR',
-    'SS',
-    'ST',
-    'SV',
-    'SX',
-    'SZ',
-    'TA',
-    'TC',
-    'TD',
-    'TF',
-    'TG',
-    'TH',
-    'TJ',
-    'TK',
-    'TL',
-    'TM',
-    'TN',
-    'TO',
-    'TR',
-    'TT',
-    'TV',
-    'TW',
-    'TZ',
-    'UA',
-    'UG',
-    'US',
-    'UY',
-    'UZ',
-    'VA',
-    'VC',
-    'VE',
-    'VG',
-    'VN',
-    'VU',
-    'WF',
-    'WS',
-    'XK',
-    'YE',
-    'YT',
-    'ZA',
-    'ZM',
-    'ZW',
-    'ZZ',
-];
-const ALLOWED = new Set(exports.STRIPE_ALLOWED_COUNTRIES);
-function isStripeAllowedCountry(code) {
-    return ALLOWED.has(code);
-}

package/core/server/services/stripe/services/checkout/field-ports.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * What Stripe Checkout will render, measured against the live API at Ghost's pinned
- * version rather than read from the reference — which disagreed with the API in three of
- * five probes, missing the field cap and the key format entirely. A wrong bound here fails
- * the session create, which fails the checkout.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHECKOUT_ELIGIBLE_FIELD_TYPES = exports.MAX_CHECKOUT_LABEL_LENGTH = exports.MAX_CHECKOUT_CUSTOM_FIELDS = exports.STRIPE_PORT = exports.STRIPE_PORTS = void 0;
-exports.isStripePort = isStripePort;
-exports.isCheckoutEligible = isCheckoutEligible;
-/** The names Stripe returns values under, and the only ports a binding for it may use. */
-exports.STRIPE_PORTS = ['shipping_name', 'shipping_address', 'phone'];
-function isStripePort(key) {
-    return exports.STRIPE_PORTS.includes(key);
-}
-exports.STRIPE_PORT = {
-    shippingName: 'shipping_name',
-    shippingAddress: 'shipping_address',
-    phone: 'phone',
-};
-/** Stripe rejects a fourth. */
-exports.MAX_CHECKOUT_CUSTOM_FIELDS = 3;
-/** Stripe caps a custom label at 50, where a field name may be 191 — hence a question label. */
-exports.MAX_CHECKOUT_LABEL_LENGTH = 50;
-/**
- * What Stripe Checkout can ask for. No `long_text`: its text input caps shorter than that
- * type allows. No `address`: Stripe has no custom-field equivalent, so an address is
- * collected through its own parameter instead.
- */
-exports.CHECKOUT_ELIGIBLE_FIELD_TYPES = ['short_text'];
-function isCheckoutEligible(type) {
-    return exports.CHECKOUT_ELIGIBLE_FIELD_TYPES.includes(type);
-}

package/core/server/services/tier-checkout-config/destinations.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PORT_FIELD = void 0;
-/**
- * What a port supplies, and what to call a field made to hold it. The type is a rule about
- * any destination: a port that returns an address can only be collected into a field that
- * keeps one. The name is used only when the request names a key the site does not keep
- * yet, which is the one moment a publisher has not chosen a label themselves.
- *
- * A key is not a port. `phone` is what Stripe calls what it returns; where it lands is
- * whatever the request said, and `Shipping Phone` is only how that field is listed.
- */
-exports.PORT_FIELD = {
-    shipping_name: { name: 'Shipping Name', type: 'short_text' },
-    shipping_address: { name: 'Shipping Address', type: 'address' },
-    phone: { name: 'Shipping Phone', type: 'short_text' },
-};

package/core/server/services/update-check/run-update-check.js

@@ -1,63 +0,0 @@
-const { parentPort, workerData } = require('worker_threads');
-
-const postParentPortMessage = (message) => {
-  if (parentPort) {
-    parentPort.postMessage(message);
-  }
-};
-
-// Exit early when cancelled to prevent stalling shutdown. No cleanup needed when cancelling as everything is idempotent and will pick up
-// where it left off on next run
-function cancel() {
-  postParentPortMessage('cancelled before completion');
-
-  if (parentPort) {
-    postParentPortMessage('cancelled');
-  } else {
-    setTimeout(() => {
-      process.exit(0);
-    }, 1000);
-  }
-}
-
-if (parentPort) {
-  parentPort.once('message', (message) => {
-    if (message === 'cancel') {
-      return cancel();
-    }
-  });
-}
-
-(async () => {
-  const startedAt = Date.now();
-  postParentPortMessage('execution started');
-  const updateCheck = require('./');
-
-  // INIT required services
-  const permissions = require('../permissions');
-  await permissions.init();
-
-  const settings = require('../settings/settings-service');
-  await settings.init();
-
-  const emailAddress = require('../email-address');
-  emailAddress.init();
-  // Finished INIT
-
-  await updateCheck({
-    rethrowErrors: true,
-    forceUpdate: workerData.forceUpdate,
-    updateCheckUrl: workerData.updateCheckUrl,
-  });
-
-  postParentPortMessage(`completed in ${Date.now() - startedAt}ms`);
-
-  if (parentPort) {
-    postParentPortMessage('done');
-  } else {
-    // give the logging pipes time finish writing before exit
-    setTimeout(() => {
-      process.exit(0);
-    }, 1000);
-  }
-})();