ghost 6.60.0 → 6.61.0

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.questionRowCodec = exports.QuestionRow = exports.collectionRowCodec = exports.CollectionRow = exports.optionsCodec = void 0;
+const zod_1 = require("zod");
+const custom_field_types_1 = require("@tryghost/custom-field-types");
+const boolean_1 = require("../../lib/db-types/boolean");
+const schema_1 = require("./schema");
+const models_1 = require("./models");
+const SEPARATOR = ',';
+exports.optionsCodec = zod_1.z.codec(schema_1.DbCheckoutOptions, models_1.CheckoutOptions, {
+    decode: (columns) => ({
+        shippingAllowedCountries: splitList(columns.shipping_allowed_countries),
+        taxNumber: columns.tax_number_collect,
+    }),
+    encode: (options) => ({
+        shipping_allowed_countries: options.shippingAllowedCountries.length
+            ? joinList(options.shippingAllowedCountries)
+            : null,
+        tax_number_collect: options.taxNumber,
+    }),
+});
+function splitList(stored) {
+    return stored ? stored.split(SEPARATOR).filter(Boolean) : [];
+}
+function joinList(values) {
+    return [...new Set(values)].join(SEPARATOR);
+}
+exports.CollectionRow = zod_1.z.object({
+    product_id: zod_1.z.string(),
+    config_id: zod_1.z.string().nullable(),
+    shipping_allowed_countries: zod_1.z.string().nullable(),
+    tax_number_collect: boolean_1.DbBoolean.nullable(),
+    shipping_name_key: zod_1.z.string().nullable(),
+    shipping_name_collectable: zod_1.z.string().nullable(),
+    shipping_address_key: zod_1.z.string().nullable(),
+    shipping_address_collectable: zod_1.z.string().nullable(),
+    phone_key: zod_1.z.string().nullable(),
+    phone_collectable: zod_1.z.string().nullable(),
+});
+exports.collectionRowCodec = exports.CollectionRow.transform((row) => {
+    const collection = collectedInto(row);
+    return {
+        tierId: row.product_id,
+        configured: row.config_id !== null,
+        collection,
+        collecting: {
+            // Stripe collects the recipient's name and their address under one parameter, so it
+            // asks for both or neither. Archiving one of the two destinations is the publisher
+            // saying they no longer want that half: the step is still worth asking for while the
+            // other half can land, and whatever arrives for the archived one is dropped. Only
+            // archiving both leaves nothing worth asking for.
+            shipping: row.shipping_name_collectable === null && row.shipping_address_collectable === null
+                ? null
+                : collection.shipping,
+            taxNumber: collection.taxNumber,
+            phone: row.phone_collectable === null ? null : collection.phone,
+        },
+    };
+});
+exports.QuestionRow = zod_1.z.object({
+    product_id: zod_1.z.string(),
+    port: zod_1.z.string(),
+    label: schema_1.DbCheckoutQuestion.shape.label,
+    optional: schema_1.DbCheckoutQuestion.shape.optional,
+    question_name: zod_1.z.string().nullable(),
+    question_type: custom_field_types_1.FieldTypeSchema.nullable(),
+});
+exports.questionRowCodec = exports.QuestionRow.transform((row) => ({
+    tierId: row.product_id,
+    question: {
+        key: row.port,
+        label: row.label,
+        optional: row.optional,
+    },
+    askable: row.question_type === null
+        ? null
+        : { prompt: row.label ?? row.question_name ?? row.port, type: row.question_type },
+}));
+function collectedInto(row) {
+    const { shippingAllowedCountries, taxNumber } = zod_1.z.decode(exports.optionsCodec, {
+        shipping_allowed_countries: row.shipping_allowed_countries,
+        tax_number_collect: row.tax_number_collect ?? false,
+    });
+    return {
+        shipping: row.shipping_name_key !== null && row.shipping_address_key !== null
+            ? {
+                allowedCountries: shippingAllowedCountries,
+                nameCustomFieldKey: row.shipping_name_key,
+                addressCustomFieldKey: row.shipping_address_key,
+            }
+            : null,
+        taxNumber,
+        phone: row.phone_key === null ? null : { customFieldKey: row.phone_key },
+    };
+}

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

@@ -0,0 +1,17 @@
+"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/tier-checkout-config/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCheckoutConfigResponse = exports.TierCheckoutConfig = exports.ShippingCollection = exports.ResolvedQuestion = exports.ResolvedCheckout = exports.PhoneCollection = exports.emptyCheckoutConfig = exports.CheckoutQuestion = exports.TierCheckoutConfigService = void 0;
+/**
+ * What a tier's checkout asks and collects.
+ *
+ * A domain of its own rather than part of the Tier aggregate: a tier is loaded into memory
+ * once at boot, and these rows are read live because deleting a custom field cascades a
+ * question away without that repository ever seeing it.
+ *
+ * Constructed by the tiers service wrapper at boot, which already holds the collaborators
+ * this needs, rather than by an init() here — the custom field services are built before
+ * it, so both are ready by the time it runs.
+ */
+var service_1 = require("./service");
+Object.defineProperty(exports, "TierCheckoutConfigService", { enumerable: true, get: function () { return service_1.TierCheckoutConfigService; } });
+var models_1 = require("./models");
+Object.defineProperty(exports, "CheckoutQuestion", { enumerable: true, get: function () { return models_1.CheckoutQuestion; } });
+Object.defineProperty(exports, "emptyCheckoutConfig", { enumerable: true, get: function () { return models_1.emptyCheckoutConfig; } });
+Object.defineProperty(exports, "PhoneCollection", { enumerable: true, get: function () { return models_1.PhoneCollection; } });
+Object.defineProperty(exports, "ResolvedCheckout", { enumerable: true, get: function () { return models_1.ResolvedCheckout; } });
+Object.defineProperty(exports, "ResolvedQuestion", { enumerable: true, get: function () { return models_1.ResolvedQuestion; } });
+Object.defineProperty(exports, "ShippingCollection", { enumerable: true, get: function () { return models_1.ShippingCollection; } });
+Object.defineProperty(exports, "TierCheckoutConfig", { enumerable: true, get: function () { return models_1.TierCheckoutConfig; } });
+var serializers_1 = require("./serializers");
+Object.defineProperty(exports, "toCheckoutConfigResponse", { enumerable: true, get: function () { return serializers_1.toCheckoutConfigResponse; } });

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolvedCheckout = exports.ResolvedQuestion = exports.CheckoutOptions = exports.emptyCheckoutConfig = exports.emptyCollection = exports.TierCheckoutConfig = exports.PhoneCollection = exports.ShippingCollection = exports.CheckoutQuestion = void 0;
+const zod_1 = require("zod");
+const custom_field_types_1 = require("@tryghost/custom-field-types");
+exports.CheckoutQuestion = zod_1.z.object({
+    key: zod_1.z.string(),
+    label: zod_1.z.string().nullable(),
+    optional: zod_1.z.boolean(),
+});
+/**
+ * One toggle and two destinations: a processor returns the recipient and the address
+ * under one parameter, but a publisher keeps a name and an address in different fields.
+ */
+exports.ShippingCollection = zod_1.z.object({
+    /** ISO 3166-1 alpha-2. A processor will not render an address form without them. */
+    allowedCountries: zod_1.z.array(zod_1.z.string()),
+    nameCustomFieldKey: zod_1.z.string(),
+    addressCustomFieldKey: zod_1.z.string(),
+});
+exports.PhoneCollection = zod_1.z.object({
+    customFieldKey: zod_1.z.string(),
+});
+exports.TierCheckoutConfig = zod_1.z.object({
+    tierId: zod_1.z.string(),
+    customFields: zod_1.z.array(exports.CheckoutQuestion),
+    shipping: exports.ShippingCollection.nullable(),
+    /** Stripe keeps a tax number against the customer it invoices; Ghost never stores one. */
+    taxNumber: zod_1.z.boolean(),
+    phone: exports.PhoneCollection.nullable(),
+});
+const emptyCollection = () => ({
+    shipping: null,
+    taxNumber: false,
+    phone: null,
+});
+exports.emptyCollection = emptyCollection;
+const emptyCheckoutConfig = (tierId) => ({
+    tierId,
+    customFields: [],
+    ...(0, exports.emptyCollection)(),
+});
+exports.emptyCheckoutConfig = emptyCheckoutConfig;
+exports.CheckoutOptions = zod_1.z.object({
+    shippingAllowedCountries: zod_1.z.array(zod_1.z.string()),
+    taxNumber: zod_1.z.boolean(),
+});
+exports.ResolvedQuestion = exports.CheckoutQuestion.extend({
+    prompt: zod_1.z.string(),
+    type: custom_field_types_1.FieldTypeSchema,
+});
+exports.ResolvedCheckout = zod_1.z.object({
+    customFields: zod_1.z.array(exports.ResolvedQuestion),
+    shipping: exports.ShippingCollection.nullable(),
+    taxNumber: zod_1.z.boolean(),
+    phone: exports.PhoneCollection.nullable(),
+});

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIELDS_TABLE = exports.BINDINGS_TABLE = exports.CONFIG_TABLE = exports.QUESTIONS_TABLE = void 0;
+exports.collectionRowsForTier = collectionRowsForTier;
+exports.configuredCollectionRows = configuredCollectionRows;
+exports.questionRows = questionRows;
+const schema_1 = require("../members-custom-fields/schema");
+const field_ports_1 = require("../stripe/services/checkout/field-ports");
+const schema_2 = require("./schema");
+exports.QUESTIONS_TABLE = 'products_checkout_fields';
+exports.CONFIG_TABLE = 'products_checkout_config';
+exports.BINDINGS_TABLE = 'members_custom_field_bindings';
+exports.FIELDS_TABLE = 'members_custom_fields';
+const ACTIVE = schema_1.FIELD_STATUS.active;
+const optionColumns = Object.keys(schema_2.DbCheckoutOptions.shape).map((column) => `${exports.CONFIG_TABLE}.${column}`);
+function collectionQuery(db) {
+    const bindTo = (alias, port) => function () {
+        this.on(`${alias}.product_id`, 'products.id').andOn(db.raw(`${alias}.port = ?`, [port]));
+    };
+    const landsIn = (alias, binding) => function () {
+        this.on(`${alias}.key`, `${binding}.custom_field_key`).andOn(db.raw(`${alias}.status = ?`, [ACTIVE]));
+    };
+    const query = db('products')
+        .leftJoin(exports.CONFIG_TABLE, `${exports.CONFIG_TABLE}.product_id`, 'products.id')
+        .leftJoin({ name_binding: exports.BINDINGS_TABLE }, bindTo('name_binding', field_ports_1.STRIPE_PORT.shippingName))
+        .leftJoin({ name_field: exports.FIELDS_TABLE }, landsIn('name_field', 'name_binding'))
+        .leftJoin({ shipping_binding: exports.BINDINGS_TABLE }, bindTo('shipping_binding', field_ports_1.STRIPE_PORT.shippingAddress))
+        .leftJoin({ shipping_field: exports.FIELDS_TABLE }, landsIn('shipping_field', 'shipping_binding'))
+        .leftJoin({ phone_binding: exports.BINDINGS_TABLE }, bindTo('phone_binding', field_ports_1.STRIPE_PORT.phone))
+        .leftJoin({ phone_field: exports.FIELDS_TABLE }, landsIn('phone_field', 'phone_binding'))
+        .orderBy('products.id', 'asc')
+        .select([
+        'products.id as product_id',
+        `${exports.CONFIG_TABLE}.id as config_id`,
+        ...optionColumns,
+        'name_binding.custom_field_key as shipping_name_key',
+        'name_field.key as shipping_name_collectable',
+        'shipping_binding.custom_field_key as shipping_address_key',
+        'shipping_field.key as shipping_address_collectable',
+        'phone_binding.custom_field_key as phone_key',
+        'phone_field.key as phone_collectable',
+    ]);
+    return query;
+}
+/** One row, whether or not that tier has ever been configured. */
+function collectionRowsForTier(db, productId) {
+    return collectionQuery(db).where('products.id', productId);
+}
+/**
+ * This query starts from products, so without a filter it would return every tier on the
+ * site, configured or not. A tier only gets a row in products_checkout_config when someone
+ * saves checkout settings for it, so requiring that row narrows the list to the tiers
+ * somebody has actually set up. A tier that was set up and then had everything switched off
+ * keeps its row and stays in the list, reporting that it collects nothing.
+ */
+function configuredCollectionRows(db) {
+    return collectionQuery(db).whereNotNull(`${exports.CONFIG_TABLE}.id`);
+}
+function questionRows(db, productId) {
+    const query = db(exports.QUESTIONS_TABLE)
+        .join(exports.BINDINGS_TABLE, `${exports.BINDINGS_TABLE}.id`, `${exports.QUESTIONS_TABLE}.binding_id`)
+        .leftJoin({ question_field: exports.FIELDS_TABLE }, function () {
+        this.on('question_field.key', `${exports.BINDINGS_TABLE}.custom_field_key`).andOn(db.raw('question_field.status = ?', [ACTIVE]));
+    })
+        .orderBy(`${exports.BINDINGS_TABLE}.product_id`, 'asc')
+        .orderBy(`${exports.QUESTIONS_TABLE}.sort_order`, 'asc')
+        .orderBy(`${exports.QUESTIONS_TABLE}.id`, 'asc')
+        .select([
+        `${exports.BINDINGS_TABLE}.product_id`,
+        `${exports.BINDINGS_TABLE}.port`,
+        `${exports.QUESTIONS_TABLE}.label`,
+        `${exports.QUESTIONS_TABLE}.optional`,
+        'question_field.name as question_name',
+        'question_field.type as question_type',
+    ]);
+    if (productId) {
+        return query.where(`${exports.BINDINGS_TABLE}.product_id`, productId);
+    }
+    return query;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbCheckoutOptions = exports.DbCheckoutConfig = exports.DbCheckoutQuestion = void 0;
+const zod_1 = require("zod");
+const boolean_1 = require("../../lib/db-types/boolean");
+const date_1 = require("../../lib/db-types/date");
+exports.DbCheckoutQuestion = zod_1.z.object({
+    id: zod_1.z.string(),
+    binding_id: zod_1.z.string(),
+    sort_order: zod_1.z.number(),
+    label: zod_1.z.string().nullable(),
+    optional: boolean_1.DbBoolean,
+    created_at: date_1.DbDate,
+    updated_at: date_1.DbDate.nullable(),
+});
+/**
+ * Options only. Whether a tier collects something it keeps is the binding; a tax number is
+ * the exception, since Stripe keeps it and Ghost never does, so there is nothing to bind.
+ */
+exports.DbCheckoutConfig = zod_1.z.object({
+    id: zod_1.z.string(),
+    product_id: zod_1.z.string(),
+    shipping_allowed_countries: zod_1.z.string().nullable(),
+    tax_number_collect: boolean_1.DbBoolean,
+    created_at: date_1.DbDate,
+    updated_at: date_1.DbDate.nullable(),
+});
+exports.DbCheckoutOptions = exports.DbCheckoutConfig.omit({
+    id: true,
+    product_id: true,
+    created_at: true,
+    updated_at: true,
+});

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCheckoutConfigResponse = exports.CheckoutConfigInput = void 0;
+const zod_1 = require("zod");
+const field_ports_1 = require("../stripe/services/checkout/field-ports");
+const allowed_countries_1 = require("../stripe/services/checkout/allowed-countries");
+const models_1 = require("./models");
+// Every country Stripe will take, sent at once, was measured as accepted — so the only
+// ceiling is the list itself, and a request naming more than there are countries is naming
+// something twice.
+const MAX_ALLOWED_COUNTRIES = allowed_countries_1.STRIPE_ALLOWED_COUNTRIES.length;
+const QuestionInput = zod_1.z.object({
+    key: zod_1.z.string().min(1, { error: 'Every checkout question needs a custom field key.' }),
+    label: zod_1.z.string().trim().min(1).nullish(),
+    optional: zod_1.z.boolean().optional(),
+});
+// Not checked against a list of countries: membership of that list is contested, and Ghost
+// is not its arbiter.
+const CountryCode = zod_1.z
+    .string()
+    .trim()
+    .regex(/^[A-Za-z]{2}$/, { error: 'Enter a 2-letter country code, like US.' })
+    .toUpperCase()
+    .refine(allowed_countries_1.isStripeAllowedCountry, {
+    error: 'Stripe will not ship to that country, so a checkout cannot offer it.',
+});
+/**
+ * Where a collected value lands is the request's to state. Ghost keeps no convention about
+ * it, so a block that collects names its destination and one that does not carries nothing
+ * to name.
+ */
+const DESTINATION_REQUIRED = 'Say which custom field this is collected into.';
+const CustomFieldKey = zod_1.z
+    .string({ error: DESTINATION_REQUIRED })
+    .min(1, { error: DESTINATION_REQUIRED });
+const Destination = zod_1.z.strictObject({ custom_field_key: CustomFieldKey }, { error: DESTINATION_REQUIRED });
+exports.CheckoutConfigInput = zod_1.z.strictObject({
+    custom_fields: zod_1.z
+        .array(QuestionInput)
+        .max(field_ports_1.MAX_CHECKOUT_CUSTOM_FIELDS, {
+        error: `A checkout can ask at most ${field_ports_1.MAX_CHECKOUT_CUSTOM_FIELDS} questions.`,
+    })
+        .refine((questions) => new Set(questions.map((question) => question.key)).size === questions.length, { error: 'This checkout already asks for that field.' })
+        .optional(),
+    shipping: zod_1.z
+        .discriminatedUnion('collect', [
+        zod_1.z.strictObject({ collect: zod_1.z.literal(false) }),
+        zod_1.z.strictObject({
+            collect: zod_1.z.literal(true),
+            allowed_countries: zod_1.z
+                .array(CountryCode, { error: 'Choose at least one country you deliver to.' })
+                .min(1, { error: 'Choose at least one country you deliver to.' })
+                .max(MAX_ALLOWED_COUNTRIES),
+            name: Destination,
+            address: Destination,
+        }),
+    ])
+        .optional(),
+    tax_number: zod_1.z.strictObject({ collect: zod_1.z.boolean() }).optional(),
+    phone: zod_1.z
+        .discriminatedUnion('collect', [
+        zod_1.z.strictObject({ collect: zod_1.z.literal(false) }),
+        zod_1.z.strictObject({ collect: zod_1.z.literal(true), custom_field_key: CustomFieldKey }),
+    ])
+        .optional(),
+});
+const QuestionResource = zod_1.z.object({
+    key: zod_1.z.string(),
+    label: zod_1.z.string().nullable(),
+    optional: zod_1.z.boolean(),
+});
+const CollectionResource = zod_1.z.object({
+    collect: zod_1.z.literal(true),
+    custom_field_key: zod_1.z.string(),
+});
+const ShippingResource = zod_1.z.object({
+    collect: zod_1.z.literal(true),
+    allowed_countries: zod_1.z.array(zod_1.z.string()),
+    name: zod_1.z.object({ custom_field_key: zod_1.z.string() }),
+    address: zod_1.z.object({ custom_field_key: zod_1.z.string() }),
+});
+const CheckoutConfigResource = zod_1.z.object({
+    tier_id: zod_1.z.string(),
+    custom_fields: zod_1.z.array(QuestionResource),
+    shipping: ShippingResource.optional(),
+    tax_number: zod_1.z.object({ collect: zod_1.z.literal(true) }).optional(),
+    phone: CollectionResource.optional(),
+});
+const CheckoutConfigResponse = zod_1.z.object({
+    tiers_checkout_config: zod_1.z.array(CheckoutConfigResource),
+});
+/** One resource per tier, so a browse and a read differ only in how many come back. */
+exports.toCheckoutConfigResponse = zod_1.z
+    .array(models_1.TierCheckoutConfig)
+    .transform((configs) => ({
+    tiers_checkout_config: configs.map((config) => ({
+        tier_id: config.tierId,
+        custom_fields: config.customFields,
+        // A block appears only when the tier collects that thing, so a client reads
+        // presence rather than a flag it would have to check.
+        ...(config.shipping
+            ? {
+                shipping: {
+                    collect: true,
+                    allowed_countries: config.shipping.allowedCountries,
+                    name: { custom_field_key: config.shipping.nameCustomFieldKey },
+                    address: { custom_field_key: config.shipping.addressCustomFieldKey },
+                },
+            }
+            : {}),
+        ...(config.taxNumber ? { tax_number: { collect: true } } : {}),
+        ...(config.phone
+            ? {
+                phone: {
+                    collect: true,
+                    custom_field_key: config.phone.customFieldKey,
+                },
+            }
+            : {}),
+    })),
+}))
+    .pipe(CheckoutConfigResponse);