@tryghost/metafield-types 0.1.2 → 0.3.0

package/build/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type FieldType } from './structure.js';
-export { FIELD_KINDS, FIELD_PARTS, FIELD_TYPE_IDS, PART_TYPE_IDS, partTypesOf, subFieldsOf, type FieldKind, type FieldType, type PartsOf, type PartType, } from './structure.js';
+import { type FieldType, type FieldShape, type TypedSettings, type ValueOf } from './structure.js';
+export { FIELD_STRUCTURES, FIELD_TYPE_IDS, LIST_SOURCES, MAX_OPTIONS, MIN_OPTIONS, OPTION_SEPARATOR, TEXT_SIZES, choice, country, editableAnswers, inOptionOrder, isFieldType, isRecordValue, matchField, matchLeaf, matchShape, partsOf, text, type ChoiceLeaf, type FieldHandlers, type FieldOfShape, type FieldShape, type FieldStructure, type FieldType, type FieldTypeOfShape, type Leaf, type LeafHandlers, type LeafKind, type ListSource, type PartsOf, type RecordStructure, type ScalarStructure, type SetSettings, type SetStructure, type SettingsOf, type ShapeHandlers, type ShapeOf, type StructureOf, type TextLeaf, type TextSize, type TypedSettings, type ValueOf, } from './structure.js';
 /**
  * The shared catalog of member metafield types.
  *
@@ -10,10 +10,9 @@ export { FIELD_KINDS, FIELD_PARTS, FIELD_TYPE_IDS, PART_TYPE_IDS, partTypesOf, s
  * last statement lives here and nowhere else, so that Ghost core, which enforces it, and
  * admin, which gives instant feedback against it, cannot disagree about what is valid.
  *
- * A type is one of two things. Most are a value in their own right, declared as the
- * schema that value must satisfy. An address is a *record*: a set of named parts, each a
- * value in the same sense, from which the whole type's schema is derived. Nothing stops a
- * part being a record itself.
+ * A type is composed of leaves, each one value with its own rule. Most types are a single
+ * leaf. An address is a *record*: a set of named parts, each a leaf, from which the whole
+ * type's rule is derived. A part is always a leaf, never a record itself.
  *
  * ## What a write may say
  *
@@ -51,12 +50,13 @@ export { FIELD_KINDS, FIELD_PARTS, FIELD_TYPE_IDS, PART_TYPE_IDS, partTypesOf, s
  * answer and a disagreement between them is a file that silently stops round-tripping.
  *
  * The line is whether more than one renderer must agree on a string, not presentation
- * against validity — the sentences above are presentation. Admin is the only renderer
- * today, so a part's label lives there, held against this file by a type. A Portal
- * collection form, which cannot reach admin's packages, moves the labels here.
+ * against validity — the sentences above are presentation. Admin and Portal each label a
+ * record's parts in their own words, and each is held against the catalog by a type, so a
+ * part added there fails to compile in both until it has a label.
  */
 export declare const FieldTypeSchema: z.ZodEnum<{
     address: "address";
+    list: "list";
     long_text: "long_text";
     short_text: "short_text";
 }>;
@@ -81,6 +81,267 @@ export declare const MEMBER_ACCESS: {
     readonly read: 'read';
     readonly write: 'write';
 };
+/**
+ * Whether a field is in use. An archived field keeps its definition and the values members
+ * hold for it, so it can be restored, but it takes no new values and members no longer see it.
+ */
+export declare const FIELD_STATUSES: readonly ['active', 'archived'];
+export type FieldStatus = (typeof FIELD_STATUSES)[number];
+export declare const FieldStatusSchema: z.ZodEnum<{
+    active: "active";
+    archived: "archived";
+}>;
+export declare const FIELD_STATUS: {
+    readonly active: 'active';
+    readonly archived: 'archived';
+};
+/**
+ * A set field's settings as stored or sent back: their shape alone, which every read checks. A
+ * write checks the rules `SetSettingsSchema` layers on top, so a rule tightened later never hides
+ * a field set up under the old one, the way a value's rule never hides what a member already holds.
+ */
+export declare const SetSettingsShape: z.ZodObject<{
+    options: z.ZodArray<z.ZodString>;
+    multiple: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * What a set field is set up with: its shape, with each option's text tidied and the rules a write
+ * must meet on top. Options are a set as well, so the same text can't be offered twice; they are
+ * listed in the order they are shown.
+ */
+export declare const SetSettingsSchema: z.ZodPipe<z.ZodObject<{
+    options: z.ZodArray<z.ZodString>;
+    multiple: z.ZodBoolean;
+}, z.core.$strip>, z.ZodTransform<{
+    options: string[];
+    multiple: boolean;
+}, {
+    options: string[];
+    multiple: boolean;
+}>>;
+/**
+ * What a field holds beside its type, `base`, with its type and the settings that type's shape
+ * takes, held as `settings` says for each shape: a set's options, and nothing for any other shape.
+ * One variant per shape, so a field's settings are always read against its type. Writes give the
+ * rules, reads the shape alone, and Ghost's table its column.
+ */
+export declare const withTypedSettings: <Base extends z.ZodRawShape, ForScalar extends z.ZodType, ForRecord extends z.ZodType, ForSet extends z.ZodType>(base: Base, settings: {
+    scalar: ForScalar;
+    record: ForRecord;
+    set: ForSet;
+} & { [S in FieldShape]: z.ZodType; }) => z.ZodDiscriminatedUnion<[z.ZodObject<Base & {
+    type: z.ZodEnum<{
+        long_text: "long_text";
+        short_text: "short_text";
+    }>;
+    settings: ForScalar & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+} extends infer T ? { -readonly [P in keyof T]: T[P]; } : never, z.core.$strip>, z.ZodObject<Base & {
+    type: z.ZodEnum<{
+        address: "address";
+    }>;
+    settings: ForRecord & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+} extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P]; } : never, z.core.$strip>, z.ZodObject<Base & {
+    type: z.ZodEnum<{
+        list: "list";
+    }>;
+    settings: ForSet & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+} extends infer T_2 ? { -readonly [P in keyof T_2]: T_2[P]; } : never, z.core.$strip>], "type">;
+/**
+ * Each shape's settings in one place: a set's options and whether a member picks several, and
+ * nothing for any other shape. A list's defaults have no options, which a list's write rules
+ * refuse, so an edit of a list read with its defaults always writes the settings it is given.
+ * Keyed by shape, so a shape added to the catalog fails to compile until it has an entry.
+ */
+export declare const SHAPE_SETTINGS: {
+    scalar: {
+        written: z.ZodOptional<z.ZodUndefined>;
+        read: z.ZodOptional<z.ZodUndefined>;
+        defaults: undefined;
+    };
+    record: {
+        written: z.ZodOptional<z.ZodUndefined>;
+        read: z.ZodOptional<z.ZodUndefined>;
+        defaults: undefined;
+    };
+    set: {
+        written: z.ZodPipe<z.ZodObject<{
+            options: z.ZodArray<z.ZodString>;
+            multiple: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodTransform<{
+            options: string[];
+            multiple: boolean;
+        }, {
+            options: string[];
+            multiple: boolean;
+        }>>;
+        read: z.ZodObject<{
+            options: z.ZodArray<z.ZodString>;
+            multiple: z.ZodBoolean;
+        }, z.core.$strip>;
+        defaults: {
+            options: never[];
+            multiple: false;
+        };
+    };
+};
+/** Each shape's settings as a write states them, checked against the rules. */
+export declare const WRITTEN_SETTINGS: {
+    scalar: z.ZodOptional<z.ZodUndefined>;
+    record: z.ZodOptional<z.ZodUndefined>;
+    set: z.ZodPipe<z.ZodObject<{
+        options: z.ZodArray<z.ZodString>;
+        multiple: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodTransform<{
+        options: string[];
+        multiple: boolean;
+    }, {
+        options: string[];
+        multiple: boolean;
+    }>>;
+};
+/** Each shape's settings as they are read back, checked for their shape alone. */
+export declare const READ_SETTINGS: {
+    scalar: z.ZodOptional<z.ZodUndefined>;
+    record: z.ZodOptional<z.ZodUndefined>;
+    set: z.ZodObject<{
+        options: z.ZodArray<z.ZodString>;
+        multiple: z.ZodBoolean;
+    }, z.core.$strip>;
+};
+/**
+ * Where a refusal points within what was sent: the path to the refused value, with its parts and
+ * positions joined by dots, such as `settings.options.2` for a field's third option. Ghost names
+ * a refusal's `property` this way, and a form files the problems it finds under the same keys, so
+ * each lands beside the input that set the value.
+ */
+export declare function refusedProperty(path: readonly PropertyKey[]): string;
+/**
+ * A field's type and settings as a write states them, checked together and against the rules:
+ * the settings must be what that type is set up with, so a list carries its options and
+ * nothing else carries any.
+ */
+export declare const TypedSettingsInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodEnum<{
+        long_text: "long_text";
+        short_text: "short_text";
+    }>;
+    settings: z.ZodOptional<z.ZodUndefined> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        address: "address";
+    }>;
+    settings: z.ZodOptional<z.ZodUndefined> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        list: "list";
+    }>;
+    settings: z.ZodPipe<z.ZodObject<{
+        options: z.ZodArray<z.ZodString>;
+        multiple: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodTransform<{
+        options: string[];
+        multiple: boolean;
+    }, {
+        options: string[];
+        multiple: boolean;
+    }>> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>], "type">;
+/** A field's type and settings as they are read back: paired, but checked for their shape alone. */
+export declare const TypedSettingsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodEnum<{
+        long_text: "long_text";
+        short_text: "short_text";
+    }>;
+    settings: z.ZodOptional<z.ZodUndefined> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        address: "address";
+    }>;
+    settings: z.ZodOptional<z.ZodUndefined> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        list: "list";
+    }>;
+    settings: z.ZodObject<{
+        options: z.ZodArray<z.ZodString>;
+        multiple: z.ZodBoolean;
+    }, z.core.$strip> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>], "type">;
+/**
+ * A field definition as the Admin and Members APIs return it. Ghost writes every definition through
+ * this and Admin reads every one through it, so both ends are checked against one shape. Portal
+ * uses the type without the check, because zod would add to every page view on every site. Dates
+ * are ISO strings, as JSON carries them.
+ */
+export declare const MetafieldDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodEnum<{
+        long_text: "long_text";
+        short_text: "short_text";
+    }>;
+    settings: z.ZodOptional<z.ZodUndefined> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    namespace: z.core.$ZodBranded<import("zod/mini").ZodMiniString<string>, "Namespace", "out">;
+    key: z.core.$ZodBranded<import("zod/mini").ZodMiniString<string>, "Key", "out">;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+    }>;
+    access: z.ZodObject<{
+        member: z.ZodEnum<{
+            none: "none";
+            read: "read";
+            write: "write";
+        }>;
+    }, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        address: "address";
+    }>;
+    settings: z.ZodOptional<z.ZodUndefined> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    namespace: z.core.$ZodBranded<import("zod/mini").ZodMiniString<string>, "Namespace", "out">;
+    key: z.core.$ZodBranded<import("zod/mini").ZodMiniString<string>, "Key", "out">;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+    }>;
+    access: z.ZodObject<{
+        member: z.ZodEnum<{
+            none: "none";
+            read: "read";
+            write: "write";
+        }>;
+    }, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        list: "list";
+    }>;
+    settings: z.ZodObject<{
+        options: z.ZodArray<z.ZodString>;
+        multiple: z.ZodBoolean;
+    }, z.core.$strip> & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    namespace: z.core.$ZodBranded<import("zod/mini").ZodMiniString<string>, "Namespace", "out">;
+    key: z.core.$ZodBranded<import("zod/mini").ZodMiniString<string>, "Key", "out">;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+    }>;
+    access: z.ZodObject<{
+        member: z.ZodEnum<{
+            none: "none";
+            read: "read";
+            write: "write";
+        }>;
+    }, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>], "type">;
+export type MetafieldDefinition = z.output<typeof MetafieldDefinitionSchema>;
 /**
  * Where a change to a member's values was made, as a member's activity feed names it.
  * Shared so a place added on the server is one Admin has to be told how to describe.
@@ -117,59 +378,15 @@ export interface MetafieldChangeEntry<TDate = string> {
  */
 export declare const MAX_LONG_TEXT_BYTES = 65535;
 /**
- * The types a composite's parts can declare, each defined once with its rule. A country
- * code and a postal code both store short text, but they are different things — the
- * part's type is what a control or a filter dispatches on, the way a field's own type
- * is for a scalar.
+ * A value of any field type, as a caller holding a field of unknown type must accept it.
  */
-export declare const PART_TYPES: {
-    short_text: z.ZodString;
-    postal_code: z.ZodString;
-    country_code: z.ZodString;
-};
-export interface FieldTypeDefinition {
-    /** What kind of value this is, for anything that has to compare one. */
-    kind: import('./structure.js').FieldKind;
-    value: z.ZodType;
-}
-export declare const FIELD_TYPES: {
-    short_text: {
-        kind: "text";
-        value: z.ZodString;
-    };
-    long_text: {
-        kind: "text";
-        value: z.ZodString;
-    };
-    address: {
-        kind: 'record';
-        value: z.ZodObject<{
-            line1: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-            line2: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-            city: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-            state: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-            postal_code: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-            country: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-        }, z.core.$strict>;
-    };
-};
-/** Named for the admin types built on it, which speak of an address rather than a record. */
-export declare const AddressValue: z.ZodObject<{
-    line1: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-    line2: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-    city: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-    state: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-    postal_code: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-    country: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
-}, z.core.$strict>;
-export type Address = z.infer<typeof AddressValue>;
+export type FieldValue = ValueOf<FieldType>;
+export type Address = ValueOf<'address'>;
 /**
- * A value of any field type, as a caller holding a field of unknown type must accept it.
- *
- * Derived from the schemas rather than listed, so a type added here widens it without
- * anyone remembering to.
+ * The rule a value of one field must satisfy. It takes the field rather than its type so that a
+ * rule depending on the field's own setup, such as the options a list field offers, changes here
+ * and nowhere else; such a rule is built from the field rather than kept per type. Throws for a
+ * type this build doesn't know.
  */
-export type FieldValue = {
-    [T in FieldType]: z.infer<(typeof FIELD_TYPES)[T]['value']>;
-}[FieldType];
+export declare function valueSchemaFor(field: TypedSettings): z.ZodType<FieldValue>;
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAA+B,KAAK,SAAS,EAAiB,MAAM,gBAAgB,CAAC;AAI5F,OAAO,EACL,WAAW,EACX,WAAW,EACX,cAAc,EACd,aAAa,EACb,WAAW,EACX,WAAW,EACX,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,QAAQ,GACd,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,eAAO,MAAM,eAAe;;;;EAAyB,CAAC;AAEtD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,YAAI,MAAM,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC;AACvE,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AACjE,eAAO,MAAM,kBAAkB;;;;EAA+B,CAAC;AAC/D,eAAO,MAAM,aAAa;mBAClB,MAAM;mBACN,MAAM;oBACL,OAAO;CACuC,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,YACnC,OAAO,EACP,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,CACF,CAAC;AACX,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E,4FAA4F;AAC5F,eAAO,MAAM,uBAAuB,WAAY,MAAM,KAAG,MAAM,IAAI,qBACD,CAAC;AAEnE,qGAAqG;AACrG,eAAO,MAAM,+BAA+B;;;;iBAI1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB,CAAC,KAAK,GAAG,MAAM;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,qBAAqB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAC9C,UAAU,EAAE,yBAAyB,EAAE,CAAC;IACxC,UAAU,EAAE,KAAK,CAAC;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AA2BzC;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;CAwBiB,CAAC;AA+BzC,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,IAAI,EAAE,OAAO,gBAAgB,EAAE,SAAS,CAAC;IACzC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC;CAClB;AA2CD,eAAO,MAAM,WAAW;;;;;;;;;;cAHP,QAAQ;;;;;;;;;;CAevB,CAAC;AAEH,6FAA6F;AAC7F,eAAO,MAAM,YAAY;;;;;;;kBAA4B,CAAC;AACtD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;KAAG,CAAC,IAAI,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;CAAE,CAAC,SAAS,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}