lkb-fields-document 1.0.0 → 1.0.1

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

@@ -1,1167 +1,16 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var lkbCore = require('lkb-core');
-var types = require('lkb-core/types');
-var graphql = require('graphql');
-var utils = require('./utils-06bcddc4.node.cjs.js');
-var slate = require('slate');
-var editorShared = require('./editor-shared-a997ae98.node.cjs.js');
-var zod = require('zod');
-var index = require('./index-c3223fdc.node.cjs.js');
-require('slate-history');
-require('@emotion/weak-memoize');
-require('./shared-4684cc24.node.cjs.js');
-require('mdast-util-from-markdown');
-require('mdast-util-gfm-autolink-literal/from-markdown');
-require('micromark-extension-gfm-autolink-literal');
-require('mdast-util-gfm-strikethrough/from-markdown');
-require('micromark-extension-gfm-strikethrough');
-require('@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();
-  }
-  utils.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)));
-      }
-  }
-  utils.assertNever(schema);
-}
-
-// leaf types
-const zMarkValue = zod.z.union([zod.z.literal(true), zod.z.undefined()]);
-const zText = zod.z.object({
-  type: zod.z.never().optional(),
-  text: zod.z.string(),
-  bold: zMarkValue,
-  italic: zMarkValue,
-  underline: zMarkValue,
-  strikethrough: zMarkValue,
-  code: zMarkValue,
-  superscript: zMarkValue,
-  subscript: zMarkValue,
-  keyboard: zMarkValue,
-  insertMenu: zMarkValue
-}).strict();
-const zTextAlign = zod.z.union([zod.z.undefined(), zod.z.literal('center'), zod.z.literal('end')]);
-
-// recursive types
-const zLink = zod.z.object({
-  type: zod.z.literal('link'),
-  href: zod.z.string().refinement(index.isValidURL, val => ({
-    code: 'custom',
-    message: `Invalid URL: ${val}`
-  }))
-}).strict();
-const zHeading = zod.z.object({
-  type: zod.z.literal('heading'),
-  textAlign: zTextAlign,
-  level: zod.z.union([zod.z.literal(1), zod.z.literal(2), zod.z.literal(3), zod.z.literal(4), zod.z.literal(5), zod.z.literal(6)])
-}).strict();
-const zParagraph = zod.z.object({
-  type: zod.z.literal('paragraph'),
-  textAlign: zTextAlign
-}).strict();
-const zBasicElement = type => zod.z.object({
-  type: zod.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 = zod.z.object({
-  type: zod.z.literal('layout'),
-  layout: zod.z.array(zod.z.number())
-}).strict();
-const zRelationshipData = zod.z.object({
-  id: zod.z.string(),
-  label: zod.z.string().optional(),
-  data: zod.z.record(zod.z.string(), zod.z.any()).optional()
-}).strict();
-const zRelationship = zod.z.object({
-  type: zod.z.literal('relationship'),
-  relationship: zod.z.string(),
-  data: zod.z.union([zRelationshipData, zod.z.null()])
-}).strict();
-const zComponentBlock = zod.z.object({
-  type: zod.z.literal('component-block'),
-  component: zod.z.string(),
-  props: zod.z.record(zod.z.string(), zod.z.any())
-}).strict();
-const zComponentProp = type => zod.z.object({
-  type: zod.z.literal(type),
-  propPath: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).optional()
-}).strict();
-const zComponentProps = [zComponentProp('component-block-prop'), zComponentProp('component-inline-prop')];
-const zBlock = zod.z.discriminatedUnion('type', [zComponentBlock.extend({
-  children: zod.z.lazy(() => zChildren)
-}), ...zComponentProps.map(prop => prop.extend({
-  children: zod.z.lazy(() => zChildren)
-})), ...zBasicElements.map(prop => prop.extend({
-  children: zod.z.lazy(() => zChildren)
-})), zHeading.extend({
-  children: zod.z.lazy(() => zChildren)
-}), zLayout.extend({
-  children: zod.z.lazy(() => zChildren)
-}), zParagraph.extend({
-  children: zod.z.lazy(() => zChildren)
-})]);
-const zInline = zod.z.discriminatedUnion('type', [zText, zLink.extend({
-  children: zod.z.lazy(() => zChildren)
-}), zRelationship.extend({
-  children: zod.z.lazy(() => zChildren)
-})]);
-const zChildren = zod.z.array(zod.z.union([zBlock, zInline]));
-const zDocument = zod.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));
-    });
-  }
-  utils.assertNever(schema);
-}
-function isText(node) {
-  return slate.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 = editorShared.createDocumentEditor(documentFeatures, componentBlocks, relationships);
-  editor.children = children;
-  slate.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 graphql.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 types.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: lkbCore.g.arg({
-            type: lkbCore.g.JSON
-          }),
-          resolve(val) {
-            if (val === undefined) {
-              val = defaultValue;
-            }
-            return inputResolver(val);
-          }
-        },
-        update: {
-          arg: lkbCore.g.arg({
-            type: lkbCore.g.JSON
-          }),
-          resolve: inputResolver
-        }
-      },
-      output: lkbCore.g.field({
-        type: lkbCore.g.object()({
-          name: `${meta.listKey}_${meta.fieldKey}_Document`,
-          fields: {
-            document: lkbCore.g.field({
-              args: {
-                hydrateRelationships: lkbCore.g.arg({
-                  type: lkbCore.g.nonNull(lkbCore.g.Boolean),
-                  defaultValue: false
-                })
-              },
-              type: lkbCore.g.nonNull(lkbCore.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 = lkbCore.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, lkbCore.g.arg({
-          type
-        })];
-      }))
-    });
-    return input;
-  }
-  if (schema.kind === 'array') {
-    const innerType = getGraphQLInputType(name, schema.element, operation, cache, meta);
-    return lkbCore.g.list(innerType);
-  }
-  if (schema.kind === 'conditional') {
-    const input = lkbCore.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, lkbCore.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}`);
-  }
-  utils.assertNever(schema);
-}
-async function getValueForUpdate(schema, value, prevValue, context, path) {
-  if (value === undefined) return prevValue;
-  if (prevValue === undefined) {
-    prevValue = utils.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 : utils.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('.')}`);
-  }
-  utils.assertNever(schema);
-}
-async function getValueForCreate(schema, value, context, path) {
-  // If value is undefined, get the specified defaultValue
-  if (value === undefined) return utils.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('.')}`);
-  }
-  utils.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 lkbCore.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 lkbCore.g.field({
-      type: lkbCore.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 lkbCore.g.field({
-      type: lkbCore.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 = lkbCore.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 lkbCore.g.object()({
-        name: innerName,
-        interfaces: [interfaceType],
-        fields: () => ({
-          discriminant: wrapGraphQLFieldInResolver(getDiscriminantField(), x => x.discriminant),
-          value: getOutputGraphQLField(`${innerName}Value`, val, interfaceImplementations, cache, meta)
-        })
-      });
-    }));
-    return lkbCore.g.field({
-      type: interfaceType,
-      resolve({
-        value
-      }) {
-        return value;
-      }
-    });
-  }
-  if (schema.kind === 'relationship') {
-    const listOutputType = meta.lists[schema.listKey].types.output;
-    return lkbCore.g.field({
-      type: schema.many ? lkbCore.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');
-  }
-  utils.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 = utils.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 types.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: lkbCore.g.arg({
-            type: getGraphQLInputType(name, schema, 'create', new Map(), meta)
-          }),
-          async resolve(val, context) {
-            return await getValueForCreate(schema, val, context, []);
-          }
-        },
-        update: {
-          arg: lkbCore.g.arg({
-            type: getGraphQLInputType(name, schema, 'update', new Map(), meta)
-          }),
-          resolve(val) {
-            return val;
-          }
-        }
-      },
-      output: lkbCore.g.field({
-        type: lkbCore.g.object()({
-          name: `${name}Output`,
-          fields: {
-            structure: getOutputGraphQLField(name, schema, unreferencedConcreteInterfaceImplementations, new Map(), meta),
-            json: lkbCore.g.field({
-              type: lkbCore.g.JSON,
-              args: {
-                hydrateRelationships: lkbCore.g.arg({
-                  type: lkbCore.g.nonNull(lkbCore.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
-    });
-  };
-}
-
-exports.document = document;
-exports.structure = structure;
+"use strict";
+// this file might look strange and you might be wondering what it's for
+// it's lets you import your source files by importing this entrypoint
+// as you would import it if it was built with preconstruct build
+// this file is slightly different to some others though
+// it has a require hook which compiles your code with Babel
+// this means that you don't have to set up @babel/register or anything like that
+// but you can still require this module and it'll be compiled
+
+// this bit of code imports the require hook and registers it
+let unregister = require("../../../node_modules/.pnpm/@preconstruct+hook@0.4.0/node_modules/@preconstruct/hook").___internalHook(typeof __dirname === 'undefined' ? undefined : __dirname, "../../..", "..");
+
+// this re-exports the source file
+module.exports = require("../src/index.ts");
+
+unregister();