lkb-fields-document 1.0.0

package/dist/lkb-fields-document.node.esm.js

@@ -0,0 +1,1162 @@
+import { g } from 'lkb-core';
+import { fieldType } from 'lkb-core/types';
+import { GraphQLError } from 'graphql';
+import { a as assertNever, g as getInitialPropsValue } from './utils-200ff260.node.esm.js';
+import { Editor, Text } from 'slate';
+import { c as createDocumentEditor } from './editor-shared-a6e340e6.node.esm.js';
+import { z } from 'zod';
+import { i as isValidURL } from './index-586adb8f.node.esm.js';
+import 'slate-history';
+import '@emotion/weak-memoize';
+import './shared-5e864055.node.esm.js';
+import 'mdast-util-from-markdown';
+import 'mdast-util-gfm-autolink-literal/from-markdown';
+import 'micromark-extension-gfm-autolink-literal';
+import 'mdast-util-gfm-strikethrough/from-markdown';
+import 'micromark-extension-gfm-strikethrough';
+import '@braintree/sanitize-url';
+
+function assertValidComponentSchema(schema, lists, mode) {
+  assertValidComponentSchemaInner(schema, [], [], new Set(), lists, mode);
+}
+
+// recursive things can exist but they have to either be:
+// - inside the non-default portion of a conditional field
+// - inside an array field
+// when we hit the non-default portion of a conditional field or an array field
+// checking inside of it essentially means pretend it's a new thing
+function assertValidComponentSchemaInner(schema, schemaAncestors, propPath, seenProps, lists, mode) {
+  if (schema.kind === 'form') {
+    if (mode === 'structure' && !schema.graphql) {
+      throw new Error(`There is a form field without a configured GraphQL schema at "${propPath.join('.')}", fields used in the structure field must have a GraphQL schema.`);
+    }
+    return;
+  }
+  if (schema.kind === 'child') {
+    if (mode === 'structure') {
+      throw new Error(`There is a child field at "${propPath.join('.')}" but child fields are not allowed in structure fields.`);
+    }
+    return;
+  }
+  if (schema.kind === 'relationship') {
+    if (lists.has(schema.listKey)) {
+      return;
+    }
+    throw new Error(`The relationship field at "${propPath.join('.')}" has the listKey "${schema.listKey}" but no list named "${schema.listKey}" exists.`);
+  }
+  const ancestor = schemaAncestors.indexOf(schema);
+  if (ancestor !== -1) {
+    throw new Error(`The field "${propPath.join('.')}" is the same as it's ancestor. Use an array or conditional field for recursive structures.`);
+  }
+  if (seenProps.has(schema)) {
+    return;
+  }
+  propPath.push(schema.kind);
+  try {
+    seenProps.add(schema);
+    if (schema.kind === 'array') {
+      assertValidComponentSchemaInner(schema.element, [], propPath, seenProps, lists, mode);
+      return;
+    }
+    if (schema.kind === 'object') {
+      schemaAncestors.push(schema);
+      for (const [key, innerProp] of Object.entries(schema.fields)) {
+        propPath.push(key);
+        if (schema.fields[key] !== innerProp) {
+          throw new Error(`Fields on an object field must not change over time but the field at "${propPath.join('.')}" changes between accesses`);
+        }
+        assertValidComponentSchemaInner(innerProp, schemaAncestors, propPath, seenProps, lists, mode);
+        propPath.pop();
+      }
+      schemaAncestors.pop();
+      return;
+    }
+    if (schema.kind === 'conditional') {
+      schemaAncestors.push(schema);
+      const stringifiedDefaultDiscriminant = schema.discriminant.defaultValue.toString();
+      for (const [key, innerProp] of Object.entries(schema.values)) {
+        propPath.push(key);
+        if (schema.values[key] !== innerProp) {
+          throw new Error(`Fields on a conditional field must not change over time but the field at "${propPath.join('.')}" changes between accesses`);
+        }
+        assertValidComponentSchemaInner(innerProp, key === stringifiedDefaultDiscriminant ? schemaAncestors : [], propPath, seenProps, lists, mode);
+        propPath.pop();
+      }
+      schemaAncestors.pop();
+      return;
+    }
+  } finally {
+    propPath.pop();
+  }
+  assertNever(schema);
+}
+
+const labelFieldAlias = '____document_field_relationship_item_label';
+const idFieldAlias = '____document_field_relationship_item_id';
+function addRelationshipData(nodes, context, relationships, componentBlocks) {
+  return Promise.all(nodes === null || nodes === void 0 ? void 0 : nodes.map(async node => {
+    if (node.type === 'relationship') {
+      const relationship = relationships[node.relationship];
+      if (!relationship) return node;
+      return {
+        ...node,
+        data: await fetchDataForOne(context, {
+          ...relationship,
+          many: false
+        }, node.data)
+      };
+    }
+    if (node.type === 'component-block') {
+      const componentBlock = componentBlocks[node.component];
+      if (componentBlock) {
+        const [props, children] = await Promise.all([addRelationshipDataToComponentProps({
+          kind: 'object',
+          fields: componentBlock.schema
+        }, node.props, (relationship, data) => fetchRelationshipData(context, relationship, data)), addRelationshipData(node.children, context, relationships, componentBlocks)]);
+        return {
+          ...node,
+          props,
+          children
+        };
+      }
+    }
+    if ('children' in node && Array.isArray(node.children)) {
+      return {
+        ...node,
+        children: await addRelationshipData(node.children, context, relationships, componentBlocks)
+      };
+    }
+    return node;
+  }));
+}
+async function fetchRelationshipData(context, relationship, data) {
+  var _relationship$labelFi;
+  if (!relationship.many) return fetchDataForOne(context, relationship, data);
+  const ids = Array.isArray(data) ? data.filter(item => item.id != null).map(x => x.id) : [];
+  if (!ids.length) return [];
+  const list = context.__internal.lists[relationship.listKey];
+  const {
+    listQueryName
+  } = list.graphql.names;
+  const labelField = (_relationship$labelFi = relationship.labelField) !== null && _relationship$labelFi !== void 0 ? _relationship$labelFi : list.ui.labelField;
+  const value = await context.graphql.run({
+    query: `query($ids: [ID!]!) {items:${listQueryName}(where: { id: { in: $ids } }) {${idFieldAlias}:id ${labelFieldAlias}:${labelField}\n${relationship.selection || ''}}}`,
+    variables: {
+      ids
+    }
+  });
+  return Array.isArray(value.items) ? value.items.map(({
+    [labelFieldAlias]: label,
+    [idFieldAlias]: id,
+    ...data
+  }) => {
+    return {
+      id,
+      label,
+      data
+    };
+  }) : [];
+}
+async function fetchDataForOne(context, relationship, data) {
+  var _relationship$labelFi2;
+  // Single related item
+  const id = data === null || data === void 0 ? void 0 : data.id;
+  if (id == null) return null;
+
+  // An exception here indicates something wrong with either the system or the
+  // configuration (e.g. a bad selection field). These will surface as system
+  // errors from the GraphQL field resolver.
+  const list = context.__internal.lists[relationship.listKey];
+  const {
+    itemQueryName
+  } = list.graphql.names;
+  const labelField = (_relationship$labelFi2 = relationship.labelField) !== null && _relationship$labelFi2 !== void 0 ? _relationship$labelFi2 : list.ui.labelField;
+  const value = await context.graphql.run({
+    query: `query($id: ID!) {item:${itemQueryName}(where: { id: $id }) {${labelFieldAlias}:${labelField}\n${relationship.selection || ''}}}`,
+    variables: {
+      id
+    }
+  });
+  if (value.item === null) return {
+    id,
+    data: undefined,
+    label: undefined
+  };
+  return {
+    id,
+    label: value.item[labelFieldAlias],
+    data: (() => {
+      const {
+        [labelFieldAlias]: _ignore,
+        ...otherData
+      } = value.item;
+      return otherData;
+    })()
+  };
+}
+async function addRelationshipDataToComponentProps(schema, value, fetchData) {
+  switch (schema.kind) {
+    case 'child':
+      return value;
+    case 'form':
+      return value;
+    case 'relationship':
+      return fetchData(schema, value);
+    case 'object':
+      {
+        return Object.fromEntries(await Promise.all(Object.keys(schema.fields).map(async key => [key,
+        // if val[key] === undefined, we know a new field was added to the schema
+        // but there is old data in the database that doesn't have the new field
+        // we're intentionally not just magically adding it because we may want to
+        // have a more optimised strategy of hydrating relationships so we don't
+        // want to add something unrelated that requires the current "traverse everything" strategy
+        value[key] === undefined ? undefined : await addRelationshipDataToComponentProps(schema.fields[key], value[key], fetchData)])));
+      }
+    case 'conditional':
+      {
+        return {
+          discriminant: value.discriminant,
+          value: await addRelationshipDataToComponentProps(schema.values[value.discriminant], value.value, fetchData)
+        };
+      }
+    case 'array':
+      {
+        return await Promise.all(value.map(async innerVal => addRelationshipDataToComponentProps(schema.element, innerVal, fetchData)));
+      }
+  }
+  assertNever(schema);
+}
+
+// leaf types
+const zMarkValue = z.union([z.literal(true), z.undefined()]);
+const zText = z.object({
+  type: z.never().optional(),
+  text: z.string(),
+  bold: zMarkValue,
+  italic: zMarkValue,
+  underline: zMarkValue,
+  strikethrough: zMarkValue,
+  code: zMarkValue,
+  superscript: zMarkValue,
+  subscript: zMarkValue,
+  keyboard: zMarkValue,
+  insertMenu: zMarkValue
+}).strict();
+const zTextAlign = z.union([z.undefined(), z.literal('center'), z.literal('end')]);
+
+// recursive types
+const zLink = z.object({
+  type: z.literal('link'),
+  href: z.string().refinement(isValidURL, val => ({
+    code: 'custom',
+    message: `Invalid URL: ${val}`
+  }))
+}).strict();
+const zHeading = z.object({
+  type: z.literal('heading'),
+  textAlign: zTextAlign,
+  level: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(5), z.literal(6)])
+}).strict();
+const zParagraph = z.object({
+  type: z.literal('paragraph'),
+  textAlign: zTextAlign
+}).strict();
+const zBasicElement = type => z.object({
+  type: z.literal(type)
+}).strict();
+const zBasicElements = [zBasicElement('blockquote'), zBasicElement('layout-area'), zBasicElement('code'), zBasicElement('divider'), zBasicElement('list-item'), zBasicElement('list-item-content'), zBasicElement('ordered-list'), zBasicElement('unordered-list')];
+const zLayout = z.object({
+  type: z.literal('layout'),
+  layout: z.array(z.number())
+}).strict();
+const zRelationshipData = z.object({
+  id: z.string(),
+  label: z.string().optional(),
+  data: z.record(z.string(), z.any()).optional()
+}).strict();
+const zRelationship = z.object({
+  type: z.literal('relationship'),
+  relationship: z.string(),
+  data: z.union([zRelationshipData, z.null()])
+}).strict();
+const zComponentBlock = z.object({
+  type: z.literal('component-block'),
+  component: z.string(),
+  props: z.record(z.string(), z.any())
+}).strict();
+const zComponentProp = type => z.object({
+  type: z.literal(type),
+  propPath: z.array(z.union([z.string(), z.number()])).optional()
+}).strict();
+const zComponentProps = [zComponentProp('component-block-prop'), zComponentProp('component-inline-prop')];
+const zBlock = z.discriminatedUnion('type', [zComponentBlock.extend({
+  children: z.lazy(() => zChildren)
+}), ...zComponentProps.map(prop => prop.extend({
+  children: z.lazy(() => zChildren)
+})), ...zBasicElements.map(prop => prop.extend({
+  children: z.lazy(() => zChildren)
+})), zHeading.extend({
+  children: z.lazy(() => zChildren)
+}), zLayout.extend({
+  children: z.lazy(() => zChildren)
+}), zParagraph.extend({
+  children: z.lazy(() => zChildren)
+})]);
+const zInline = z.discriminatedUnion('type', [zText, zLink.extend({
+  children: z.lazy(() => zChildren)
+}), zRelationship.extend({
+  children: z.lazy(() => zChildren)
+})]);
+const zChildren = z.array(z.union([zBlock, zInline]));
+const zDocument = z.array(zBlock);
+
+// exports
+
+function isRelationshipData(value) {
+  return zRelationshipData.safeParse(value).success;
+}
+function validateDocumentStructure(value) {
+  const result = zDocument.safeParse(value);
+  if (!result.success) {
+    throw new Error(`Invalid document structure: ${result.error.message}`);
+  }
+}
+
+class PropValidationError extends Error {
+  constructor(message, path) {
+    super(`${message} at ${path.join('.')}`);
+    this.path = path;
+  }
+}
+function validateComponentBlockProps(schema, value, relationships, path) {
+  if (schema.kind === 'form') {
+    value = value === undefined ? schema.defaultValue : value;
+    if (schema.validate(value)) {
+      return value;
+    }
+    throw new PropValidationError(`Invalid form prop value: ${JSON.stringify(value)}`, path);
+  }
+  if (schema.kind === 'child') {
+    return null;
+  }
+  if (schema.kind === 'relationship') {
+    if (schema.many) {
+      if (Array.isArray(value) && value.every(isRelationshipData)) {
+        // yes, ts understands this completely correctly, i'm as suprised as you are
+        return value.map(x => ({
+          id: x.id
+        }));
+      } else {
+        throw new PropValidationError(`Invalid relationship value: ${JSON.stringify(value)}`, path);
+      }
+    }
+    if (value === null || isRelationshipData(value)) {
+      return value === null ? null : {
+        id: value.id
+      };
+    } else {
+      throw new PropValidationError(`Invalid relationship value: ${JSON.stringify(value)}`, path);
+    }
+  }
+  if (schema.kind === 'conditional') {
+    if (typeof value !== 'object' || value === null) {
+      throw new PropValidationError(`Conditional value must be an object but is ${typeof value}`, path);
+    }
+    for (const key of Object.keys(value)) {
+      if (key !== 'discriminant' && key !== 'value') {
+        throw new PropValidationError(`Conditional value only allows keys named "discriminant" and "value", not "${key}"`, path);
+      }
+    }
+    const discriminant = value.discriminant;
+    const val = value.value;
+    // for some reason mongo or mongoose or something is saving undefined as null
+    // so we're doing this so that we avoid setting undefined on objects
+    const obj = {};
+    const discriminantVal = validateComponentBlockProps(schema.discriminant, discriminant, relationships, path.concat('discriminant'));
+    if (discriminantVal !== undefined) {
+      obj.discriminant = discriminantVal;
+    }
+    const conditionalFieldValue = validateComponentBlockProps(schema.values[discriminant], val, relationships, path.concat('value'));
+    if (conditionalFieldValue !== undefined) {
+      obj.value = conditionalFieldValue;
+    }
+    return obj;
+  }
+  if (schema.kind === 'object') {
+    if (typeof value !== 'object' || value === null) {
+      throw new PropValidationError(`Object value must be an object but is ${typeof value}`, path);
+    }
+    const val = {};
+    for (const key of Object.keys(schema.fields)) {
+      const propVal = validateComponentBlockProps(schema.fields[key], value[key], relationships, path.concat(key));
+      // for some reason mongo or mongoose or something is saving undefined as null
+      // so we're doing this so that we avoid setting undefined on objects
+      if (propVal !== undefined) {
+        val[key] = propVal;
+      }
+    }
+    return val;
+  }
+  if (schema.kind === 'array') {
+    if (!Array.isArray(value)) {
+      throw new PropValidationError(`Array field value must be an array but is ${typeof value}`, path);
+    }
+    return value.map((innerVal, i) => {
+      return validateComponentBlockProps(schema.element, innerVal, relationships, path.concat(i));
+    });
+  }
+  assertNever(schema);
+}
+function isText(node) {
+  return Text.isText(node);
+}
+
+// note that the errors thrown from here will only be exposed
+// as internal server error from the graphql api in prod
+// this is fine because these cases are pretty much all about
+// malicious content being inserted, not valid content
+function getValidatedNodeWithNormalizedComponentFormProps(node, componentBlocks, relationships) {
+  if (isText(node)) return node;
+  if (node.type === 'component-block') {
+    if (Object.prototype.hasOwnProperty.call(componentBlocks, node.component)) {
+      const componentBlock = componentBlocks[node.component];
+      node = {
+        ...node,
+        props: validateComponentBlockProps({
+          kind: 'object',
+          fields: componentBlock.schema
+        }, node.props, relationships, [])
+      };
+    }
+  }
+  if (node.type === 'relationship') {
+    var _node$data;
+    node = {
+      type: 'relationship',
+      data: ((_node$data = node.data) === null || _node$data === void 0 ? void 0 : _node$data.id) !== undefined ? {
+        id: node.data.id,
+        data: undefined,
+        label: undefined
+      } : null,
+      relationship: node.relationship,
+      children: node.children
+    };
+  }
+  return {
+    ...node,
+    children: node.children.map(x => getValidatedNodeWithNormalizedComponentFormProps(x, componentBlocks, relationships))
+  };
+}
+function validateAndNormalizeDocument(value, documentFeatures, componentBlocks, relationships) {
+  validateDocumentStructure(value);
+  const children = value.map(x => getValidatedNodeWithNormalizedComponentFormProps(x, componentBlocks, relationships));
+  const editor = createDocumentEditor(documentFeatures, componentBlocks, relationships);
+  editor.children = children;
+  Editor.normalize(editor, {
+    force: true
+  });
+  return editor.children;
+}
+
+function normaliseDocumentFeatures(config) {
+  var _config$formatting;
+  const {
+    alignment,
+    blockTypes,
+    headingLevels,
+    inlineMarks,
+    listTypes,
+    softBreaks
+  } = typeof config.formatting === 'boolean' ? {
+    alignment: config.formatting,
+    blockTypes: config.formatting,
+    headingLevels: config.formatting,
+    inlineMarks: config.formatting,
+    listTypes: config.formatting,
+    softBreaks: config.formatting
+  } : (_config$formatting = config.formatting) !== null && _config$formatting !== void 0 ? _config$formatting : {};
+  const documentFeatures = {
+    formatting: {
+      alignment: {
+        center: typeof alignment === 'boolean' ? alignment : !!(alignment !== null && alignment !== void 0 && alignment.center),
+        end: typeof alignment === 'boolean' ? alignment : !!(alignment !== null && alignment !== void 0 && alignment.end)
+      },
+      blockTypes: {
+        blockquote: typeof blockTypes === 'boolean' ? blockTypes : !!(blockTypes !== null && blockTypes !== void 0 && blockTypes.blockquote),
+        code: typeof blockTypes === 'boolean' ? blockTypes : !!(blockTypes !== null && blockTypes !== void 0 && blockTypes.code)
+      },
+      headingLevels: typeof headingLevels === 'boolean' ? [1, 2, 3, 4, 5, 6].filter(_ => headingLevels) : [...new Set(headingLevels)].sort(),
+      inlineMarks: {
+        bold: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.bold),
+        code: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.code),
+        italic: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.italic),
+        strikethrough: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.strikethrough),
+        underline: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.underline),
+        keyboard: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.keyboard),
+        subscript: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.subscript),
+        superscript: typeof inlineMarks === 'boolean' ? inlineMarks : !!(inlineMarks !== null && inlineMarks !== void 0 && inlineMarks.superscript)
+      },
+      listTypes: {
+        ordered: typeof listTypes === 'boolean' ? listTypes : !!(listTypes !== null && listTypes !== void 0 && listTypes.ordered),
+        unordered: typeof listTypes === 'boolean' ? listTypes : !!(listTypes !== null && listTypes !== void 0 && listTypes.unordered)
+      },
+      softBreaks: typeof softBreaks === 'boolean' ? softBreaks : !!softBreaks
+    },
+    links: !!config.links,
+    layouts: [...new Set((config.layouts || []).map(x => JSON.stringify(x)))].map(x => JSON.parse(x)),
+    dividers: !!config.dividers
+  };
+  return documentFeatures;
+}
+
+function normaliseRelationships(configRelationships, meta) {
+  if (!configRelationships) return {};
+  const relationships = {};
+  for (const [key, relationship] of Object.entries(configRelationships)) {
+    var _relationship$labelFi, _relationship$selecti;
+    if (meta.lists[relationship.listKey] === undefined) {
+      throw new Error(`An inline relationship ${relationship.label} (${key}) in the field at ${meta.listKey}.${meta.fieldKey} has listKey set to "${relationship.listKey}" but no list named "${relationship.listKey}" exists.`);
+    }
+    relationships[key] = {
+      ...relationship,
+      labelField: (_relationship$labelFi = relationship.labelField) !== null && _relationship$labelFi !== void 0 ? _relationship$labelFi : null,
+      selection: (_relationship$selecti = relationship.selection) !== null && _relationship$selecti !== void 0 ? _relationship$selecti : null
+    };
+  }
+  return relationships;
+}
+
+function document({
+  componentBlocks = {},
+  dividers,
+  formatting,
+  layouts,
+  relationships: configRelationships,
+  links,
+  ...config
+} = {}) {
+  return meta => {
+    var _config$db, _config$db2;
+    const documentFeatures = normaliseDocumentFeatures({
+      dividers,
+      formatting,
+      layouts,
+      links
+    });
+    const relationships = normaliseRelationships(configRelationships, meta);
+    const inputResolver = data => {
+      if (data === null) throw new GraphQLError('Input error: Document fields cannot be set to null');
+      if (data === undefined) return data;
+      return validateAndNormalizeDocument(data, documentFeatures, componentBlocks, relationships);
+    };
+    if (config.isIndexed === 'unique') {
+      throw Error("isIndexed: 'unique' is not a supported option for field type document");
+    }
+    const lists = new Set(Object.keys(meta.lists));
+    for (const [name, block] of Object.entries(componentBlocks)) {
+      try {
+        assertValidComponentSchema({
+          kind: 'object',
+          fields: block.schema
+        }, lists, 'document');
+      } catch (err) {
+        throw new Error(`Component block ${name} in ${meta.listKey}.${meta.fieldKey}: ${err.message}`);
+      }
+    }
+    const defaultValue = [{
+      type: 'paragraph',
+      children: [{
+        text: ''
+      }]
+    }];
+    return fieldType({
+      kind: 'scalar',
+      scalar: 'Json',
+      mode: 'required',
+      default: meta.provider === 'sqlite' ? undefined : {
+        kind: 'literal',
+        // TODO: waiting on https://github.com/prisma/prisma/issues/26571
+        //   input.create manages defaultValues anyway
+        value: JSON.stringify(defaultValue !== null && defaultValue !== void 0 ? defaultValue : null)
+      },
+      map: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.map,
+      extendPrismaSchema: (_config$db2 = config.db) === null || _config$db2 === void 0 ? void 0 : _config$db2.extendPrismaSchema
+    })({
+      ...config,
+      input: {
+        create: {
+          arg: g.arg({
+            type: g.JSON
+          }),
+          resolve(val) {
+            if (val === undefined) {
+              val = defaultValue;
+            }
+            return inputResolver(val);
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.JSON
+          }),
+          resolve: inputResolver
+        }
+      },
+      output: g.field({
+        type: g.object()({
+          name: `${meta.listKey}_${meta.fieldKey}_Document`,
+          fields: {
+            document: g.field({
+              args: {
+                hydrateRelationships: g.arg({
+                  type: g.nonNull(g.Boolean),
+                  defaultValue: false
+                })
+              },
+              type: g.nonNull(g.JSON),
+              resolve({
+                document
+              }, {
+                hydrateRelationships
+              }, context) {
+                return hydrateRelationships ? addRelationshipData(document, context, relationships, componentBlocks) : document;
+              }
+            })
+          }
+        }),
+        resolve({
+          value
+        }) {
+          if (value === null) return null;
+          return {
+            document: value
+          };
+        }
+      }),
+      views: 'lkb-fields-document/views',
+      getAdminMeta() {
+        return {
+          relationships,
+          documentFeatures,
+          componentBlocksPassedOnServer: Object.keys(componentBlocks)
+        };
+      }
+    });
+  };
+}
+
+function getGraphQLInputType(name, schema, operation, cache, meta) {
+  if (!cache.has(schema)) {
+    const res = getGraphQLInputTypeInner(name, schema, operation, cache, meta);
+    cache.set(schema, res);
+  }
+  return cache.get(schema);
+}
+function getGraphQLInputTypeInner(name, schema, operation, cache, meta) {
+  if (schema.kind === 'form') {
+    if (!schema.graphql) {
+      throw new Error(`Field at ${name} is missing a graphql field`);
+    }
+    return schema.graphql.input;
+  }
+  if (schema.kind === 'object') {
+    const input = g.inputObject({
+      name: `${name}${operation[0].toUpperCase()}${operation.slice(1)}Input`,
+      fields: () => Object.fromEntries(Object.entries(schema.fields).map(([key, val]) => {
+        const type = getGraphQLInputType(`${name}${key[0].toUpperCase()}${key.slice(1)}`, val, operation, cache, meta);
+        return [key, g.arg({
+          type
+        })];
+      }))
+    });
+    return input;
+  }
+  if (schema.kind === 'array') {
+    const innerType = getGraphQLInputType(name, schema.element, operation, cache, meta);
+    return g.list(innerType);
+  }
+  if (schema.kind === 'conditional') {
+    const input = g.inputObject({
+      name: `${name}${operation[0].toUpperCase()}${operation.slice(1)}Input`,
+      fields: () => Object.fromEntries(Object.entries(schema.values).map(([key, val]) => {
+        const type = getGraphQLInputType(`${name}${key[0].toUpperCase()}${key.slice(1)}`, val, operation, cache, meta);
+        return [key, g.arg({
+          type
+        })];
+      }))
+    });
+    return input;
+  }
+  if (schema.kind === 'relationship') {
+    const inputType = meta.lists[schema.listKey].types.relateTo[schema.many ? 'many' : 'one'][operation];
+    // there are cases where this won't exist
+    // for example if gql omit is enabled on the related field
+    if (inputType === undefined) {
+      throw new Error('');
+    }
+    return inputType;
+  }
+  if (schema.kind === 'child') {
+    throw new Error(`Child fields are not supported in the structure field, found one at ${name}`);
+  }
+  assertNever(schema);
+}
+async function getValueForUpdate(schema, value, prevValue, context, path) {
+  if (value === undefined) return prevValue;
+  if (prevValue === undefined) {
+    prevValue = getInitialPropsValue(schema);
+  }
+  if (schema.kind === 'form') {
+    if (schema.validate(value)) return value;
+    throw new Error(`The value of the form field at '${path.join('.')}' is invalid`);
+  }
+  if (value === null) {
+    throw new Error(`${schema.kind[0].toUpperCase() + schema.kind.slice(1)} fields cannot be set to null but the field at '${path.join('.')}' is null`);
+  }
+  if (schema.kind === 'object') {
+    return Object.fromEntries(await Promise.all(Object.entries(schema.fields).map(async ([key, val]) => {
+      return [key, await getValueForUpdate(val, value[key], prevValue[key], context, path.concat(key))];
+    })));
+  }
+  if (schema.kind === 'array') {
+    return Promise.all(value.map((val, i) => getValueForUpdate(schema.element, val, prevValue[i], context, path.concat(i))));
+  }
+  if (schema.kind === 'relationship') {
+    if (schema.many) {
+      const val = value;
+      return resolveRelateToManyForUpdateInput(val, context, schema.listKey, prevValue);
+    } else {
+      const val = value;
+      return resolveRelateToOneForUpdateInput(val, context, schema.listKey);
+    }
+  }
+  if (schema.kind === 'conditional') {
+    const conditionalValueKeys = Object.keys(value);
+    if (conditionalValueKeys.length !== 1) {
+      throw new Error(`Conditional field inputs must set exactly one of the fields but the field at ${path.join('.')} has ${conditionalValueKeys.length} fields set`);
+    }
+    const key = conditionalValueKeys[0];
+    let discriminant = key;
+    if ((key === 'true' || key === 'false') && !schema.discriminant.validate(key)) {
+      discriminant = key === 'true';
+    }
+    return {
+      discriminant,
+      value: await getValueForUpdate(schema.values[key], value[key], prevValue.discriminant === discriminant ? prevValue.value : getInitialPropsValue(schema), context, path.concat('value'))
+    };
+  }
+  if (schema.kind === 'child') {
+    throw new Error(`Child fields are not supported in the structure field, found one at ${path.join('.')}`);
+  }
+  assertNever(schema);
+}
+async function getValueForCreate(schema, value, context, path) {
+  // If value is undefined, get the specified defaultValue
+  if (value === undefined) return getInitialPropsValue(schema);
+  if (schema.kind === 'form') {
+    if (schema.validate(value)) return value;
+    throw new Error(`The value of the form field at '${path.join('.')}' is invalid`);
+  }
+  if (value === null) {
+    throw new Error(`${schema.kind[0].toUpperCase() + schema.kind.slice(1)} fields cannot be set to null but the field at '${path.join('.')}' is null`);
+  }
+  if (schema.kind === 'array') {
+    return Promise.all(value.map((val, i) => getValueForCreate(schema.element, val, context, path.concat(i))));
+  }
+  if (schema.kind === 'object') {
+    return Object.fromEntries(await Promise.all(Object.entries(schema.fields).map(async ([key, val]) => {
+      return [key, await getValueForCreate(val, value[key], context, path.concat(key))];
+    })));
+  }
+  if (schema.kind === 'relationship') {
+    if (schema.many) {
+      const val = value;
+      return resolveRelateToManyForCreateInput(val, context, schema.listKey);
+    } else {
+      const val = value;
+      return resolveRelateToOneForCreateInput(val, context, schema.listKey);
+    }
+  }
+  if (schema.kind === 'conditional') {
+    if (value === null) throw new Error();
+    const conditionalValueKeys = Object.keys(value);
+    if (conditionalValueKeys.length !== 1) throw new Error();
+    const key = conditionalValueKeys[0];
+    let discriminant = key;
+    if ((key === 'true' || key === 'false') && !schema.discriminant.validate(key)) {
+      discriminant = key === 'true';
+    }
+    return {
+      discriminant,
+      value: await getValueForCreate(schema.values[key], value[key], context, path.concat('value'))
+    };
+  }
+  if (schema.kind === 'child') {
+    throw new Error(`Child fields are not supported in the structure field, found one at ${path.join('.')}`);
+  }
+  assertNever(schema);
+}
+/** MANY */
+
+class RelationshipErrors extends Error {
+  constructor(errors) {
+    super('Multiple relationship errors');
+    this.errors = errors;
+  }
+}
+function getResolvedUniqueWheres(uniqueInputs, context, foreignListKey, operation) {
+  return uniqueInputs.map(uniqueInput => checkUniqueItemExists(uniqueInput, foreignListKey, context, operation));
+}
+
+// these aren't here out of thinking this is better syntax(i do not think it is),
+// it's just because TS won't infer the arg is X bit
+const isFulfilled = arg => arg.status === 'fulfilled';
+const isRejected = arg => arg.status === 'rejected';
+async function resolveRelateToManyForCreateInput(value, context, foreignListKey, tag) {
+  if (!Array.isArray(value.connect) && !Array.isArray(value.create)) {
+    throw new Error(`You must provide "connect" or "create" in to-many relationship inputs for "create" operations.`);
+  }
+
+  // Perform queries for the connections
+  const connects = Promise.allSettled(getResolvedUniqueWheres(value.connect || [], context, foreignListKey, 'connect'));
+
+  // Perform nested mutations for the creations
+  const creates = Promise.allSettled((value.create || []).map(x => resolveCreateMutation(x, context, foreignListKey)));
+  const [connectResult, createResult] = await Promise.all([connects, creates]);
+
+  // Collect all the errors
+  const errors = [...connectResult, ...createResult].filter(isRejected);
+  if (errors.length) {
+    // readd tag
+    throw new RelationshipErrors(errors.map(x => ({
+      error: x.reason,
+      tag: tag || ''
+    })));
+  }
+
+  // Perform queries for the connections
+  return [...connectResult, ...createResult].filter(isFulfilled).map(x => x.value);
+}
+async function resolveRelateToManyForUpdateInput(value, context, foreignListKey, prevVal) {
+  if (!Array.isArray(value.connect) && !Array.isArray(value.create) && !Array.isArray(value.disconnect) && !Array.isArray(value.set)) {
+    throw new Error(`You must provide at least one of "set", "connect", "create" or "disconnect" in to-many relationship inputs for "update" operations.`);
+  }
+  if (value.set && value.disconnect) {
+    throw new Error(`The "set" and "disconnect" fields cannot both be provided to to-many relationship inputs for "update" operations.`);
+  }
+
+  // Perform queries for the connections
+  const connects = Promise.allSettled(getResolvedUniqueWheres(value.connect || [], context, foreignListKey, 'connect'));
+  const disconnects = Promise.allSettled(getResolvedUniqueWheres(value.disconnect || [], context, foreignListKey, 'disconnect'));
+  const sets = Promise.allSettled(getResolvedUniqueWheres(value.set || [], context, foreignListKey, 'set'));
+
+  // Perform nested mutations for the creations
+  const creates = Promise.allSettled((value.create || []).map(x => resolveCreateMutation(x, context, foreignListKey)));
+  const [connectResult, createResult, disconnectResult, setResult] = await Promise.all([connects, creates, disconnects, sets]);
+
+  // Collect all the errors
+  const errors = [...connectResult, ...createResult, ...disconnectResult, ...setResult].filter(isRejected);
+  if (errors.length) throw new RelationshipErrors(errors.map(x => ({
+    error: x.reason,
+    tag: ''
+  })));
+  let values = prevVal;
+  if (value.set) {
+    values = setResult.filter(isFulfilled).map(x => x.value);
+  }
+  const idsToDisconnect = new Set(disconnectResult.filter(isFulfilled).map(x => x.value.id));
+  values = values.filter(x => !idsToDisconnect.has(x.id));
+  values.push(...connectResult.filter(isFulfilled).map(x => x.value));
+  values.push(...createResult.filter(isFulfilled).map(x => x.value));
+  return values;
+}
+
+/** ONE */
+
+function missingItem(operation, uniqueWhere) {
+  throw new Error(`You cannot ${operation} the item '${JSON.stringify(uniqueWhere)}' - it may not exist`);
+}
+async function checkUniqueItemExists(uniqueInput, listKey, context, operation) {
+  // Check whether the item exists (from this users POV).
+  const item = await context.db[listKey].findOne({
+    where: uniqueInput
+  });
+  if (item === null) throw missingItem(operation, uniqueInput);
+  return {
+    id: item.id.toString()
+  };
+}
+async function handleCreateAndUpdate(value, context, foreignListKey) {
+  if (value.connect) return checkUniqueItemExists(value.connect, foreignListKey, context, 'connect');
+  return resolveCreateMutation(value, context, foreignListKey);
+}
+async function resolveCreateMutation(value, context, foreignListKey) {
+  const mutationType = context.graphql.schema.getMutationType();
+  const {
+    id
+  } = await mutationType.getFields()[context.__internal.lists[foreignListKey].graphql.names.createMutationName].resolve({}, {
+    data: value.create
+  }, context,
+  // we happen to know this isn't used
+  // no one else should rely on that though
+  // it could change in the future
+  {});
+  return {
+    id: id.toString()
+  };
+}
+function resolveRelateToOneForCreateInput(value, context, foreignListKey) {
+  const numOfKeys = Object.keys(value).length;
+  if (numOfKeys !== 1) throw new Error(`You must provide "connect" or "create" in to-one relationship inputs for "create" operations.`);
+  return handleCreateAndUpdate(value, context, foreignListKey);
+}
+function resolveRelateToOneForUpdateInput(value, context, foreignListKey) {
+  if (Object.keys(value).length !== 1) throw new Error(`You must provide one of "connect", "create" or "disconnect" in to-one relationship inputs for "update" operations.`);
+  if (value.connect || value.create) return handleCreateAndUpdate(value, context, foreignListKey);
+  if (value.disconnect) return null;
+}
+
+function wrapGraphQLFieldInResolver(inputField, getVal) {
+  return g.field({
+    type: inputField.type,
+    args: inputField.args,
+    deprecationReason: inputField.deprecationReason,
+    description: inputField.description,
+    extensions: inputField.extensions,
+    resolve(value, args, context, info) {
+      const val = getVal(value);
+      if (!inputField.resolve) {
+        return val;
+      }
+      return inputField.resolve({
+        value: val
+      }, args, context, info);
+    }
+  });
+}
+function getOutputGraphQLField(name, schema, interfaceImplementations, cache, meta) {
+  if (!cache.has(schema)) {
+    const res = getOutputGraphQLFieldInner(name, schema, interfaceImplementations, cache, meta);
+    cache.set(schema, res);
+  }
+  return cache.get(schema);
+}
+function getOutputGraphQLFieldInner(name, schema, interfaceImplementations, cache, meta) {
+  if (schema.kind === 'form') {
+    if (!schema.graphql) {
+      throw new Error(`Field at ${name} is missing a graphql field`);
+    }
+    return wrapGraphQLFieldInResolver(schema.graphql.output, x => x.value);
+  }
+  if (schema.kind === 'object') {
+    return g.field({
+      type: g.object()({
+        name,
+        fields: () => Object.fromEntries(Object.entries(schema.fields).map(([key, val]) => {
+          const field = getOutputGraphQLField(`${name}${key[0].toUpperCase()}${key.slice(1)}`, val, interfaceImplementations, cache, meta);
+          return [key, wrapGraphQLFieldInResolver(field, source => source[key])];
+        }))
+      }),
+      resolve({
+        value
+      }) {
+        return value;
+      }
+    });
+  }
+  if (schema.kind === 'array') {
+    const innerField = getOutputGraphQLField(name, schema.element, interfaceImplementations, cache, meta);
+    const resolve = innerField.resolve;
+    return g.field({
+      type: g.list(innerField.type),
+      args: innerField.args,
+      deprecationReason: innerField.deprecationReason,
+      description: innerField.description,
+      extensions: innerField.extensions,
+      resolve({
+        value
+      }, args, context, info) {
+        if (!resolve) {
+          return value;
+        }
+        return value.map(val => resolve({
+          value: val
+        }, args, context, info));
+      }
+    });
+  }
+  if (schema.kind === 'conditional') {
+    let discriminantField;
+    const getDiscriminantField = () => {
+      if (!discriminantField) {
+        discriminantField = getOutputGraphQLField(name + 'Discriminant', schema.discriminant, interfaceImplementations, cache, meta);
+      }
+      return discriminantField;
+    };
+    const interfaceType = g.interface()({
+      name,
+      resolveType: value => {
+        const stringifiedDiscriminant = value.discriminant.toString();
+        return name + stringifiedDiscriminant[0].toUpperCase() + stringifiedDiscriminant.slice(1);
+      },
+      fields: () => ({
+        discriminant: getDiscriminantField()
+      })
+    });
+    interfaceImplementations.push(...Object.entries(schema.values).map(([key, val]) => {
+      const innerName = name + key[0].toUpperCase() + key.slice(1);
+      return g.object()({
+        name: innerName,
+        interfaces: [interfaceType],
+        fields: () => ({
+          discriminant: wrapGraphQLFieldInResolver(getDiscriminantField(), x => x.discriminant),
+          value: getOutputGraphQLField(`${innerName}Value`, val, interfaceImplementations, cache, meta)
+        })
+      });
+    }));
+    return g.field({
+      type: interfaceType,
+      resolve({
+        value
+      }) {
+        return value;
+      }
+    });
+  }
+  if (schema.kind === 'relationship') {
+    const listOutputType = meta.lists[schema.listKey].types.output;
+    return g.field({
+      type: schema.many ? g.list(listOutputType) : listOutputType,
+      resolve({
+        value
+      }, args, context) {
+        if (Array.isArray(value)) {
+          return context.db[schema.listKey].findMany({
+            where: {
+              id: {
+                in: value.map(x => x.id)
+              }
+            }
+          });
+        }
+        if ((value === null || value === void 0 ? void 0 : value.id) == null) {
+          return null;
+        }
+        return context.db[schema.listKey].findOne({
+          where: {
+            id: value.id
+          }
+        });
+      }
+    });
+  }
+  if (schema.kind === 'child') {
+    throw new Error('Child fields are not supported in the structure field');
+  }
+  assertNever(schema);
+}
+
+function structure({
+  schema,
+  ...config
+}) {
+  return meta => {
+    var _config$hooks, _config$hooks2, _config$db, _config$hooks3, _config$hooks4;
+    if (config.isIndexed === 'unique') {
+      throw Error("isIndexed: 'unique' is not a supported option for field type structure");
+    }
+    const lists = new Set(Object.keys(meta.lists));
+    try {
+      assertValidComponentSchema(schema, lists, 'structure');
+    } catch (err) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey}: ${err.message}`);
+    }
+    const defaultValue = getInitialPropsValue(schema);
+    const unreferencedConcreteInterfaceImplementations = [];
+    const name = meta.listKey + meta.fieldKey[0].toUpperCase() + meta.fieldKey.slice(1);
+    const innerUpdate = typeof ((_config$hooks = config.hooks) === null || _config$hooks === void 0 ? void 0 : _config$hooks.resolveInput) === 'function' ? config.hooks.resolveInput : (_config$hooks2 = config.hooks) === null || _config$hooks2 === void 0 || (_config$hooks2 = _config$hooks2.resolveInput) === null || _config$hooks2 === void 0 ? void 0 : _config$hooks2.update;
+    return fieldType({
+      kind: 'scalar',
+      scalar: 'Json',
+      default: meta.provider === 'sqlite' ? undefined : {
+        kind: 'literal',
+        // TODO: waiting on https://github.com/prisma/prisma/issues/26571
+        //   input.create manages defaultValues anyway
+        value: JSON.stringify(defaultValue !== null && defaultValue !== void 0 ? defaultValue : null)
+      },
+      map: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.map,
+      mode: 'required'
+    })({
+      ...config,
+      hooks: {
+        ...config.hooks,
+        resolveInput: {
+          create: typeof ((_config$hooks3 = config.hooks) === null || _config$hooks3 === void 0 ? void 0 : _config$hooks3.resolveInput) === 'function' ? config.hooks.resolveInput : (_config$hooks4 = config.hooks) === null || _config$hooks4 === void 0 || (_config$hooks4 = _config$hooks4.resolveInput) === null || _config$hooks4 === void 0 ? void 0 : _config$hooks4.create,
+          update: async args => {
+            let val = args.resolvedData[meta.fieldKey];
+            let prevVal = args.item[meta.fieldKey];
+            val = await getValueForUpdate(schema, val, prevVal, args.context, []);
+            return innerUpdate ? innerUpdate({
+              ...args,
+              resolvedData: {
+                ...args.resolvedData,
+                [meta.fieldKey]: val
+              }
+            }) : val;
+          }
+        }
+      },
+      input: {
+        create: {
+          arg: g.arg({
+            type: getGraphQLInputType(name, schema, 'create', new Map(), meta)
+          }),
+          async resolve(val, context) {
+            return await getValueForCreate(schema, val, context, []);
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: getGraphQLInputType(name, schema, 'update', new Map(), meta)
+          }),
+          resolve(val) {
+            return val;
+          }
+        }
+      },
+      output: g.field({
+        type: g.object()({
+          name: `${name}Output`,
+          fields: {
+            structure: getOutputGraphQLField(name, schema, unreferencedConcreteInterfaceImplementations, new Map(), meta),
+            json: g.field({
+              type: g.JSON,
+              args: {
+                hydrateRelationships: g.arg({
+                  type: g.nonNull(g.Boolean),
+                  defaultValue: false
+                })
+              },
+              resolve({
+                value
+              }, args, context) {
+                if (!args.hydrateRelationships) return value;
+                return addRelationshipDataToComponentProps(schema, value, (schema, value) => {
+                  return fetchRelationshipData(context, schema, value);
+                });
+              }
+            })
+          }
+        }),
+        resolve(source) {
+          return source;
+        }
+      }),
+      views: 'lkb-fields-document/structure-views',
+      getAdminMeta: () => ({}),
+      unreferencedConcreteInterfaceImplementations
+    });
+  };
+}
+
+export { document, structure };