@nixxie-cms/core 1.0.0

package/dist/resolve-hooks-17aafd37.esm.js

@@ -0,0 +1,2026 @@
+import 'pluralize';
+import { g, f as fieldType, o as orderDirectionEnum, Q as QueryMode } from './next-fields-9bf04ed8.esm.js';
+import '@graphql-ts/schema';
+import '@graphql-ts/extend';
+import { GraphQLError } from 'graphql';
+
+const userInputError = msg => new GraphQLError(`Input error: ${msg}`, {
+  extensions: {
+    code: 'KS_USER_INPUT_ERROR'
+  }
+});
+const accessDeniedError = (msg, code = 'KS_ACCESS_DENIED') => new GraphQLError(`Access denied: ${msg}`, {
+  extensions: {
+    code
+  }
+});
+const validationFailureError = messages => {
+  const s = messages.map(m => `  - ${m}`).join('\n');
+  return new GraphQLError(`You provided invalid data for this operation.\n${s}`, {
+    extensions: {
+      code: 'KS_VALIDATION_FAILURE'
+    }
+  });
+};
+const extensionError = (extension, things) => {
+  const s = things.map(t => `  - ${t.tag}: ${t.error.message}`).join('\n');
+  return new GraphQLError(`An error occurred while running "${extension}".\n${s}`, {
+    extensions: {
+      code: 'KS_EXTENSION_ERROR',
+      debug: things.map(t => ({
+        stacktrace: t.error.stack,
+        message: t.error.message
+      }))
+    }
+  });
+};
+const resolverError = things => {
+  const s = things.map(t => `  - ${t.tag}: ${t.error.message}`).join('\n');
+  return new GraphQLError(`An error occurred while resolving input fields.\n${s}`, {
+    extensions: {
+      code: 'KS_RESOLVER_ERROR',
+      debug: things.map(t => ({
+        stacktrace: t.error.stack,
+        message: t.error.message
+      }))
+    }
+  });
+};
+const relationshipError = things => {
+  const s = things.map(t => `  - ${t.tag}: ${t.error.message}`).sort().join('\n');
+  return new GraphQLError(`An error occurred while resolving relationship fields.\n${s}`, {
+    extensions: {
+      code: 'KS_RELATIONSHIP_ERROR',
+      debug: things.map(t => ({
+        stacktrace: t.error.stack,
+        message: t.error.message
+      }))
+    }
+  });
+};
+const accessReturnError = things => {
+  const s = things.map(t => `  - ${t.tag}: Returned: ${t.returned}. Expected: boolean.`).join('\n');
+  return new GraphQLError(`Invalid values returned from access control function.\n${s}`, {
+    extensions: {
+      code: 'KS_ACCESS_RETURN_ERROR'
+    }
+  });
+};
+const limitsExceededError = _ => new GraphQLError('Your request exceeded server limits', {
+  extensions: {
+    code: 'KS_LIMITS_EXCEEDED'
+  }
+});
+function formatKeys(keys) {
+  if (keys.length < 4) return keys.join(', ');
+  return keys.slice(0, 3).join(', ') + ` and ${keys.length - 3} others...`;
+}
+const filterAccessError = ({
+  operation,
+  fieldKeys
+}) => accessDeniedError(`You cannot ${operation} by ${formatKeys(fieldKeys)}`, `KS_FILTER_DENIED`);
+
+function isInt(x) {
+  if (x === null) return;
+  if (x === '') return;
+  const nom = typeof x === 'string' ? Number(x) : x;
+  if (Number.isInteger(nom)) return nom;
+}
+function isBigInt(x) {
+  if (x === null) return;
+  if (x === '') return;
+  try {
+    return BigInt(x);
+  } catch {}
+}
+function isString(x) {
+  if (typeof x !== 'string') return;
+  if (x === '') return;
+  return x;
+}
+
+// TODO: this should be on the user, remove in breaking change?
+function isUuid(x) {
+  if (typeof x !== 'string') return;
+  if (x === '') return;
+  return x.toLowerCase();
+}
+const nonCircularFields = {
+  equals: g.arg({
+    type: g.ID
+  }),
+  in: g.arg({
+    type: g.list(g.nonNull(g.ID))
+  }),
+  notIn: g.arg({
+    type: g.list(g.nonNull(g.ID))
+  }),
+  lt: g.arg({
+    type: g.ID
+  }),
+  lte: g.arg({
+    type: g.ID
+  }),
+  gt: g.arg({
+    type: g.ID
+  }),
+  gte: g.arg({
+    type: g.ID
+  })
+};
+const IDFilter = g.inputObject({
+  name: 'IDFilter',
+  fields: () => ({
+    ...nonCircularFields,
+    not: g.arg({
+      type: IDFilter
+    })
+  })
+});
+const filterArg = g.arg({
+  type: IDFilter
+});
+function resolveInput(input, parseId) {
+  const where = {};
+  if (input === null) return where;
+  for (const key of ['equals', 'gt', 'gte', 'lt', 'lte']) {
+    const value = input[key];
+    if (value === undefined) continue;
+    where[key] = parseId(value);
+  }
+  for (const key of ['in', 'notIn']) {
+    const value = input[key];
+    if (!Array.isArray(value)) continue;
+    where[key] = value.map(x => parseId(x));
+  }
+  if (input.not !== undefined) {
+    where.not = resolveInput(input.not, parseId);
+  }
+  return where;
+}
+const NATIVE_TYPES = {
+  postgresql: {
+    uuid: 'Uuid'
+  }
+};
+function unpack(i) {
+  if (i.kind === 'random') {
+    const {
+      kind,
+      bytes,
+      encoding
+    } = i;
+    if (typeof bytes === 'number') {
+      if (bytes !== bytes >>> 0) {
+        throw new TypeError(`Expected positive integer for random bytes, not ${bytes}`);
+      }
+    }
+    return {
+      scalar: 'String',
+      // our defaults are 32 bytes, as base64url
+      //   256 / Math.log2(64) ~ 43 characters
+      //
+      // for case-insensitive databases that is
+      //   225 bits ~ Math.log2((26 + 10 + 2) ** 43)
+      default: {
+        kind,
+        bytes: bytes !== null && bytes !== void 0 ? bytes : 32,
+        encoding: encoding !== null && encoding !== void 0 ? encoding : 'base64url'
+      }
+    };
+  }
+  const {
+    kind,
+    type
+  } = i;
+  if (kind === 'cuid') return {
+    scalar: 'String',
+    default: {
+      kind,
+      version: i.version
+    }
+  };
+  if (kind === 'uuid') return {
+    scalar: 'String',
+    default: {
+      kind,
+      version: i.version
+    }
+  };
+  if (kind === 'nanoid') return {
+    scalar: 'String',
+    default: {
+      kind,
+      length: i.length
+    }
+  };
+  if (kind === 'ulid') return {
+    scalar: 'String',
+    default: {
+      kind
+    }
+  };
+  if (kind === 'string') return {
+    scalar: 'String',
+    default: undefined
+  };
+  if (kind === 'number') return {
+    scalar: type !== null && type !== void 0 ? type : 'Int',
+    default: undefined
+  };
+  if (kind === 'autoincrement') return {
+    scalar: type !== null && type !== void 0 ? type : 'Int',
+    default: {
+      kind
+    }
+  };
+  throw new Error(`Unknown id type ${kind}`);
+}
+function idFieldType(config) {
+  const kind = config.kind;
+  const dbFieldOptions = unpack(config);
+  const parseTypeFn = {
+    Int: isInt,
+    BigInt: isBigInt,
+    String: isString,
+    UUID: isUuid // TODO: remove in breaking change
+  }[kind === 'uuid' ? 'UUID' : dbFieldOptions.scalar];
+  function parse(value) {
+    const result = parseTypeFn(value);
+    if (result === undefined) {
+      throw userInputError(`Only a ${dbFieldOptions.scalar.toLowerCase()} can be passed to id filters`);
+    }
+    return result;
+  }
+  return meta => {
+    var _NATIVE_TYPES$meta$pr;
+    if (meta.provider === 'sqlite' && kind === 'autoincrement' && dbFieldOptions.scalar === 'BigInt') {
+      throw new Error(`{ kind: ${kind}, type: ${dbFieldOptions.scalar} } is not supported by SQLite`);
+    }
+    return fieldType({
+      ...dbFieldOptions,
+      kind: 'scalar',
+      mode: 'required',
+      nativeType: (_NATIVE_TYPES$meta$pr = NATIVE_TYPES[meta.provider]) === null || _NATIVE_TYPES$meta$pr === void 0 ? void 0 : _NATIVE_TYPES$meta$pr[kind]
+    })({
+      ...config,
+      // the ID field is always filterable and orderable
+      isFilterable: true,
+      // TODO: should it be?
+      isOrderable: true,
+      // TODO: should it be?
+
+      input: {
+        where: {
+          arg: filterArg,
+          resolve(val) {
+            return resolveInput(val, parse);
+          }
+        },
+        uniqueWhere: {
+          arg: g.arg({
+            type: g.ID
+          }),
+          resolve: parse
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.nonNull(g.ID),
+        resolve({
+          value
+        }) {
+          return value.toString();
+        }
+      }),
+      views: '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/id-field-view',
+      getAdminMeta: () => ({
+        kind,
+        type: dbFieldOptions.scalar
+      }),
+      ui: {
+        createView: {
+          fieldMode: 'hidden'
+        },
+        itemView: {
+          fieldPosition: 'sidebar'
+        }
+      }
+    });
+  };
+}
+
+// yes, these two types have the fields but they're semantically different types
+// (even though, yes, having EnumFilter by defined as EnumNullableFilter<Enum>, would be the same type but names would show up differently in editors for example)
+
+function enumFilters(enumType) {
+  const optional = g.inputObject({
+    name: `${enumType.name}NullableFilter`,
+    fields: () => ({
+      equals: g.arg({
+        type: enumType
+      }),
+      in: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      notIn: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      not: g.arg({
+        type: optional
+      })
+    })
+  });
+  const required = g.inputObject({
+    name: `${enumType.name}Filter`,
+    fields: () => ({
+      equals: g.arg({
+        type: enumType
+      }),
+      in: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      notIn: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      not: g.arg({
+        type: optional
+      })
+    })
+  });
+  const many = g.inputObject({
+    name: `${enumType.name}NullableListFilter`,
+    fields: () => ({
+      // can be null
+      equals: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      // can be null
+      has: g.arg({
+        type: enumType
+      }),
+      hasEvery: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      hasSome: g.arg({
+        type: g.list(g.nonNull(enumType))
+      }),
+      isEmpty: g.arg({
+        type: enumType
+      })
+    })
+  });
+  return {
+    optional,
+    required,
+    many
+  };
+}
+
+// Do not manually modify this file, it is automatically generated by the package at /prisma-utils in this repo.
+const StringNullableFilter$2 = g.inputObject({
+  name: 'StringNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    mode: g.arg({
+      type: QueryMode
+    }),
+    not: g.arg({
+      type: StringNullableFilter$2
+    }) // can be null
+  })
+});
+const StringFilter$2 = g.inputObject({
+  name: 'StringFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    mode: g.arg({
+      type: QueryMode
+    }),
+    not: g.arg({
+      type: NestedStringFilter$2
+    })
+  })
+});
+const NestedStringNullableFilter$2 = g.inputObject({
+  name: 'NestedStringNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringNullableFilter$2
+    }) // can be null
+  })
+});
+const NestedStringFilter$2 = g.inputObject({
+  name: 'NestedStringFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringFilter$2
+    })
+  })
+});
+const BooleanNullableFilter$2 = g.inputObject({
+  name: 'BooleanNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Boolean
+    }),
+    // can be null
+    not: g.arg({
+      type: BooleanNullableFilter$2
+    }) // can be null
+  })
+});
+const BooleanFilter$2 = g.inputObject({
+  name: 'BooleanFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Boolean
+    }),
+    not: g.arg({
+      type: BooleanFilter$2
+    })
+  })
+});
+const IntFilter$2 = g.inputObject({
+  name: 'IntFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Int
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    lt: g.arg({
+      type: g.Int
+    }),
+    lte: g.arg({
+      type: g.Int
+    }),
+    gt: g.arg({
+      type: g.Int
+    }),
+    gte: g.arg({
+      type: g.Int
+    }),
+    not: g.arg({
+      type: IntFilter$2
+    })
+  })
+});
+const IntNullableFilter$2 = g.inputObject({
+  name: 'IntNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Int
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Int
+    }),
+    lte: g.arg({
+      type: g.Int
+    }),
+    gt: g.arg({
+      type: g.Int
+    }),
+    gte: g.arg({
+      type: g.Int
+    }),
+    not: g.arg({
+      type: IntNullableFilter$2
+    }) // can be null
+  })
+});
+const FloatNullableFilter$2 = g.inputObject({
+  name: 'FloatNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Float
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Float
+    }),
+    lte: g.arg({
+      type: g.Float
+    }),
+    gt: g.arg({
+      type: g.Float
+    }),
+    gte: g.arg({
+      type: g.Float
+    }),
+    not: g.arg({
+      type: FloatNullableFilter$2
+    }) // can be null
+  })
+});
+const FloatFilter$2 = g.inputObject({
+  name: 'FloatFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Float
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    lt: g.arg({
+      type: g.Float
+    }),
+    lte: g.arg({
+      type: g.Float
+    }),
+    gt: g.arg({
+      type: g.Float
+    }),
+    gte: g.arg({
+      type: g.Float
+    }),
+    not: g.arg({
+      type: FloatFilter$2
+    })
+  })
+});
+const DateTimeNullableFilter$2 = g.inputObject({
+  name: 'DateTimeNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.DateTime
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.DateTime
+    }),
+    lte: g.arg({
+      type: g.DateTime
+    }),
+    gt: g.arg({
+      type: g.DateTime
+    }),
+    gte: g.arg({
+      type: g.DateTime
+    }),
+    not: g.arg({
+      type: DateTimeNullableFilter$2
+    }) // can be null
+  })
+});
+const DateTimeFilter$2 = g.inputObject({
+  name: 'DateTimeFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.DateTime
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    lt: g.arg({
+      type: g.DateTime
+    }),
+    lte: g.arg({
+      type: g.DateTime
+    }),
+    gt: g.arg({
+      type: g.DateTime
+    }),
+    gte: g.arg({
+      type: g.DateTime
+    }),
+    not: g.arg({
+      type: DateTimeFilter$2
+    })
+  })
+});
+const DecimalNullableFilter$2 = g.inputObject({
+  name: 'DecimalNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Decimal
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Decimal
+    }),
+    lte: g.arg({
+      type: g.Decimal
+    }),
+    gt: g.arg({
+      type: g.Decimal
+    }),
+    gte: g.arg({
+      type: g.Decimal
+    }),
+    not: g.arg({
+      type: DecimalNullableFilter$2
+    }) // can be null
+  })
+});
+const DecimalFilter$2 = g.inputObject({
+  name: 'DecimalFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Decimal
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    lt: g.arg({
+      type: g.Decimal
+    }),
+    lte: g.arg({
+      type: g.Decimal
+    }),
+    gt: g.arg({
+      type: g.Decimal
+    }),
+    gte: g.arg({
+      type: g.Decimal
+    }),
+    not: g.arg({
+      type: DecimalFilter$2
+    })
+  })
+});
+const BigIntNullableFilter$2 = g.inputObject({
+  name: 'BigIntNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.BigInt
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.BigInt
+    }),
+    lte: g.arg({
+      type: g.BigInt
+    }),
+    gt: g.arg({
+      type: g.BigInt
+    }),
+    gte: g.arg({
+      type: g.BigInt
+    }),
+    not: g.arg({
+      type: BigIntNullableFilter$2
+    }) // can be null
+  })
+});
+const BigIntFilter$2 = g.inputObject({
+  name: 'BigIntFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.BigInt
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    lt: g.arg({
+      type: g.BigInt
+    }),
+    lte: g.arg({
+      type: g.BigInt
+    }),
+    gt: g.arg({
+      type: g.BigInt
+    }),
+    gte: g.arg({
+      type: g.BigInt
+    }),
+    not: g.arg({
+      type: BigIntFilter$2
+    })
+  })
+});
+const String$2 = {
+  optional: StringNullableFilter$2,
+  required: StringFilter$2
+};
+const Boolean$2 = {
+  optional: BooleanNullableFilter$2,
+  required: BooleanFilter$2
+};
+const Int$2 = {
+  optional: IntNullableFilter$2,
+  required: IntFilter$2
+};
+const Float$2 = {
+  optional: FloatNullableFilter$2,
+  required: FloatFilter$2
+};
+const DateTime$2 = {
+  optional: DateTimeNullableFilter$2,
+  required: DateTimeFilter$2
+};
+const Decimal$2 = {
+  optional: DecimalNullableFilter$2,
+  required: DecimalFilter$2
+};
+const BigInt$3 = {
+  optional: BigIntNullableFilter$2,
+  required: BigIntFilter$2
+};
+
+var postgresql = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  String: String$2,
+  Boolean: Boolean$2,
+  Int: Int$2,
+  Float: Float$2,
+  DateTime: DateTime$2,
+  Decimal: Decimal$2,
+  BigInt: BigInt$3,
+  'enum': enumFilters
+});
+
+// Do not manually modify this file, it is automatically generated by the package at /prisma-utils in this repo.
+const StringNullableFilter$1 = g.inputObject({
+  name: 'StringNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: StringNullableFilter$1
+    }) // can be null
+  })
+});
+const StringFilter$1 = g.inputObject({
+  name: 'StringFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringFilter$1
+    })
+  })
+});
+const NestedStringNullableFilter$1 = g.inputObject({
+  name: 'NestedStringNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringNullableFilter$1
+    }) // can be null
+  })
+});
+const NestedStringFilter$1 = g.inputObject({
+  name: 'NestedStringFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringFilter$1
+    })
+  })
+});
+const BooleanNullableFilter$1 = g.inputObject({
+  name: 'BooleanNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Boolean
+    }),
+    // can be null
+    not: g.arg({
+      type: BooleanNullableFilter$1
+    }) // can be null
+  })
+});
+const BooleanFilter$1 = g.inputObject({
+  name: 'BooleanFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Boolean
+    }),
+    not: g.arg({
+      type: BooleanFilter$1
+    })
+  })
+});
+const IntFilter$1 = g.inputObject({
+  name: 'IntFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Int
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    lt: g.arg({
+      type: g.Int
+    }),
+    lte: g.arg({
+      type: g.Int
+    }),
+    gt: g.arg({
+      type: g.Int
+    }),
+    gte: g.arg({
+      type: g.Int
+    }),
+    not: g.arg({
+      type: IntFilter$1
+    })
+  })
+});
+const IntNullableFilter$1 = g.inputObject({
+  name: 'IntNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Int
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Int
+    }),
+    lte: g.arg({
+      type: g.Int
+    }),
+    gt: g.arg({
+      type: g.Int
+    }),
+    gte: g.arg({
+      type: g.Int
+    }),
+    not: g.arg({
+      type: IntNullableFilter$1
+    }) // can be null
+  })
+});
+const FloatNullableFilter$1 = g.inputObject({
+  name: 'FloatNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Float
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Float
+    }),
+    lte: g.arg({
+      type: g.Float
+    }),
+    gt: g.arg({
+      type: g.Float
+    }),
+    gte: g.arg({
+      type: g.Float
+    }),
+    not: g.arg({
+      type: FloatNullableFilter$1
+    }) // can be null
+  })
+});
+const FloatFilter$1 = g.inputObject({
+  name: 'FloatFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Float
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    lt: g.arg({
+      type: g.Float
+    }),
+    lte: g.arg({
+      type: g.Float
+    }),
+    gt: g.arg({
+      type: g.Float
+    }),
+    gte: g.arg({
+      type: g.Float
+    }),
+    not: g.arg({
+      type: FloatFilter$1
+    })
+  })
+});
+const DateTimeNullableFilter$1 = g.inputObject({
+  name: 'DateTimeNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.DateTime
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.DateTime
+    }),
+    lte: g.arg({
+      type: g.DateTime
+    }),
+    gt: g.arg({
+      type: g.DateTime
+    }),
+    gte: g.arg({
+      type: g.DateTime
+    }),
+    not: g.arg({
+      type: DateTimeNullableFilter$1
+    }) // can be null
+  })
+});
+const DateTimeFilter$1 = g.inputObject({
+  name: 'DateTimeFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.DateTime
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    lt: g.arg({
+      type: g.DateTime
+    }),
+    lte: g.arg({
+      type: g.DateTime
+    }),
+    gt: g.arg({
+      type: g.DateTime
+    }),
+    gte: g.arg({
+      type: g.DateTime
+    }),
+    not: g.arg({
+      type: DateTimeFilter$1
+    })
+  })
+});
+const DecimalNullableFilter$1 = g.inputObject({
+  name: 'DecimalNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Decimal
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Decimal
+    }),
+    lte: g.arg({
+      type: g.Decimal
+    }),
+    gt: g.arg({
+      type: g.Decimal
+    }),
+    gte: g.arg({
+      type: g.Decimal
+    }),
+    not: g.arg({
+      type: DecimalNullableFilter$1
+    }) // can be null
+  })
+});
+const DecimalFilter$1 = g.inputObject({
+  name: 'DecimalFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Decimal
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    lt: g.arg({
+      type: g.Decimal
+    }),
+    lte: g.arg({
+      type: g.Decimal
+    }),
+    gt: g.arg({
+      type: g.Decimal
+    }),
+    gte: g.arg({
+      type: g.Decimal
+    }),
+    not: g.arg({
+      type: DecimalFilter$1
+    })
+  })
+});
+const BigIntNullableFilter$1 = g.inputObject({
+  name: 'BigIntNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.BigInt
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.BigInt
+    }),
+    lte: g.arg({
+      type: g.BigInt
+    }),
+    gt: g.arg({
+      type: g.BigInt
+    }),
+    gte: g.arg({
+      type: g.BigInt
+    }),
+    not: g.arg({
+      type: BigIntNullableFilter$1
+    }) // can be null
+  })
+});
+const BigIntFilter$1 = g.inputObject({
+  name: 'BigIntFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.BigInt
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    lt: g.arg({
+      type: g.BigInt
+    }),
+    lte: g.arg({
+      type: g.BigInt
+    }),
+    gt: g.arg({
+      type: g.BigInt
+    }),
+    gte: g.arg({
+      type: g.BigInt
+    }),
+    not: g.arg({
+      type: BigIntFilter$1
+    })
+  })
+});
+const String$1 = {
+  optional: StringNullableFilter$1,
+  required: StringFilter$1
+};
+const Boolean$1 = {
+  optional: BooleanNullableFilter$1,
+  required: BooleanFilter$1
+};
+const Int$1 = {
+  optional: IntNullableFilter$1,
+  required: IntFilter$1
+};
+const Float$1 = {
+  optional: FloatNullableFilter$1,
+  required: FloatFilter$1
+};
+const DateTime$1 = {
+  optional: DateTimeNullableFilter$1,
+  required: DateTimeFilter$1
+};
+const Decimal$1 = {
+  optional: DecimalNullableFilter$1,
+  required: DecimalFilter$1
+};
+const BigInt$2 = {
+  optional: BigIntNullableFilter$1,
+  required: BigIntFilter$1
+};
+
+var sqlite = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  String: String$1,
+  Boolean: Boolean$1,
+  Int: Int$1,
+  Float: Float$1,
+  DateTime: DateTime$1,
+  Decimal: Decimal$1,
+  BigInt: BigInt$2,
+  'enum': enumFilters
+});
+
+// Do not manually modify this file, it is automatically generated by the package at /prisma-utils in this repo.
+const StringNullableFilter = g.inputObject({
+  name: 'StringNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    search: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: StringNullableFilter
+    }) // can be null
+  })
+});
+const StringFilter = g.inputObject({
+  name: 'StringFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    search: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringFilter
+    })
+  })
+});
+const NestedStringNullableFilter = g.inputObject({
+  name: 'NestedStringNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    search: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringNullableFilter
+    }) // can be null
+  })
+});
+const NestedStringFilter = g.inputObject({
+  name: 'NestedStringFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.String
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.String))
+    }),
+    lt: g.arg({
+      type: g.String
+    }),
+    lte: g.arg({
+      type: g.String
+    }),
+    gt: g.arg({
+      type: g.String
+    }),
+    gte: g.arg({
+      type: g.String
+    }),
+    contains: g.arg({
+      type: g.String
+    }),
+    startsWith: g.arg({
+      type: g.String
+    }),
+    endsWith: g.arg({
+      type: g.String
+    }),
+    search: g.arg({
+      type: g.String
+    }),
+    not: g.arg({
+      type: NestedStringFilter
+    })
+  })
+});
+const BooleanNullableFilter = g.inputObject({
+  name: 'BooleanNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Boolean
+    }),
+    // can be null
+    not: g.arg({
+      type: BooleanNullableFilter
+    }) // can be null
+  })
+});
+const BooleanFilter = g.inputObject({
+  name: 'BooleanFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Boolean
+    }),
+    not: g.arg({
+      type: BooleanFilter
+    })
+  })
+});
+const IntFilter = g.inputObject({
+  name: 'IntFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Int
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    lt: g.arg({
+      type: g.Int
+    }),
+    lte: g.arg({
+      type: g.Int
+    }),
+    gt: g.arg({
+      type: g.Int
+    }),
+    gte: g.arg({
+      type: g.Int
+    }),
+    not: g.arg({
+      type: IntFilter
+    })
+  })
+});
+const IntNullableFilter = g.inputObject({
+  name: 'IntNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Int
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Int))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Int
+    }),
+    lte: g.arg({
+      type: g.Int
+    }),
+    gt: g.arg({
+      type: g.Int
+    }),
+    gte: g.arg({
+      type: g.Int
+    }),
+    not: g.arg({
+      type: IntNullableFilter
+    }) // can be null
+  })
+});
+const FloatNullableFilter = g.inputObject({
+  name: 'FloatNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Float
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Float
+    }),
+    lte: g.arg({
+      type: g.Float
+    }),
+    gt: g.arg({
+      type: g.Float
+    }),
+    gte: g.arg({
+      type: g.Float
+    }),
+    not: g.arg({
+      type: FloatNullableFilter
+    }) // can be null
+  })
+});
+const FloatFilter = g.inputObject({
+  name: 'FloatFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Float
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Float))
+    }),
+    lt: g.arg({
+      type: g.Float
+    }),
+    lte: g.arg({
+      type: g.Float
+    }),
+    gt: g.arg({
+      type: g.Float
+    }),
+    gte: g.arg({
+      type: g.Float
+    }),
+    not: g.arg({
+      type: FloatFilter
+    })
+  })
+});
+const DateTimeNullableFilter = g.inputObject({
+  name: 'DateTimeNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.DateTime
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.DateTime
+    }),
+    lte: g.arg({
+      type: g.DateTime
+    }),
+    gt: g.arg({
+      type: g.DateTime
+    }),
+    gte: g.arg({
+      type: g.DateTime
+    }),
+    not: g.arg({
+      type: DateTimeNullableFilter
+    }) // can be null
+  })
+});
+const DateTimeFilter = g.inputObject({
+  name: 'DateTimeFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.DateTime
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.DateTime))
+    }),
+    lt: g.arg({
+      type: g.DateTime
+    }),
+    lte: g.arg({
+      type: g.DateTime
+    }),
+    gt: g.arg({
+      type: g.DateTime
+    }),
+    gte: g.arg({
+      type: g.DateTime
+    }),
+    not: g.arg({
+      type: DateTimeFilter
+    })
+  })
+});
+const DecimalNullableFilter = g.inputObject({
+  name: 'DecimalNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Decimal
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.Decimal
+    }),
+    lte: g.arg({
+      type: g.Decimal
+    }),
+    gt: g.arg({
+      type: g.Decimal
+    }),
+    gte: g.arg({
+      type: g.Decimal
+    }),
+    not: g.arg({
+      type: DecimalNullableFilter
+    }) // can be null
+  })
+});
+const DecimalFilter = g.inputObject({
+  name: 'DecimalFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.Decimal
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.Decimal))
+    }),
+    lt: g.arg({
+      type: g.Decimal
+    }),
+    lte: g.arg({
+      type: g.Decimal
+    }),
+    gt: g.arg({
+      type: g.Decimal
+    }),
+    gte: g.arg({
+      type: g.Decimal
+    }),
+    not: g.arg({
+      type: DecimalFilter
+    })
+  })
+});
+const BigIntNullableFilter = g.inputObject({
+  name: 'BigIntNullableFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.BigInt
+    }),
+    // can be null
+    in: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    // can be null
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    // can be null
+    lt: g.arg({
+      type: g.BigInt
+    }),
+    lte: g.arg({
+      type: g.BigInt
+    }),
+    gt: g.arg({
+      type: g.BigInt
+    }),
+    gte: g.arg({
+      type: g.BigInt
+    }),
+    not: g.arg({
+      type: BigIntNullableFilter
+    }) // can be null
+  })
+});
+const BigIntFilter = g.inputObject({
+  name: 'BigIntFilter',
+  fields: () => ({
+    equals: g.arg({
+      type: g.BigInt
+    }),
+    in: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    notIn: g.arg({
+      type: g.list(g.nonNull(g.BigInt))
+    }),
+    lt: g.arg({
+      type: g.BigInt
+    }),
+    lte: g.arg({
+      type: g.BigInt
+    }),
+    gt: g.arg({
+      type: g.BigInt
+    }),
+    gte: g.arg({
+      type: g.BigInt
+    }),
+    not: g.arg({
+      type: BigIntFilter
+    })
+  })
+});
+const String = {
+  optional: StringNullableFilter,
+  required: StringFilter
+};
+const Boolean = {
+  optional: BooleanNullableFilter,
+  required: BooleanFilter
+};
+const Int = {
+  optional: IntNullableFilter,
+  required: IntFilter
+};
+const Float = {
+  optional: FloatNullableFilter,
+  required: FloatFilter
+};
+const DateTime = {
+  optional: DateTimeNullableFilter,
+  required: DateTimeFilter
+};
+const Decimal = {
+  optional: DecimalNullableFilter,
+  required: DecimalFilter
+};
+const BigInt$1 = {
+  optional: BigIntNullableFilter,
+  required: BigIntFilter
+};
+
+var mysql = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  String: String,
+  Boolean: Boolean,
+  Int: Int,
+  Float: Float,
+  DateTime: DateTime,
+  Decimal: Decimal,
+  BigInt: BigInt$1,
+  'enum': enumFilters
+});
+
+function mergeVoidFn(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return async args => {
+    await (a === null || a === void 0 ? void 0 : a(args));
+    await (b === null || b === void 0 ? void 0 : b(args));
+  };
+}
+function merge(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  if (typeof a === 'function' && typeof b === 'function') {
+    return mergeVoidFn(a, b);
+  }
+  const expandedA = expandHooks(a);
+  const expandedB = expandHooks(b);
+  return {
+    create: mergeVoidFn(expandedA.create, expandedB.create),
+    update: mergeVoidFn(expandedA.update, expandedB.update),
+    delete: mergeVoidFn(expandedA.delete, expandedB.delete)
+  };
+}
+function expandHooks(fn) {
+  return typeof fn === 'function' ? {
+    create: fn,
+    update: fn,
+    delete: fn
+  } : fn;
+}
+const emptyFn = () => {};
+function expandVoidHooks(hooks) {
+  var _expanded$create, _expanded$update, _expanded$delete;
+  const expanded = hooks ? expandHooks(hooks) : {};
+  return {
+    create: (_expanded$create = expanded.create) !== null && _expanded$create !== void 0 ? _expanded$create : emptyFn,
+    update: (_expanded$update = expanded.update) !== null && _expanded$update !== void 0 ? _expanded$update : emptyFn,
+    delete: (_expanded$delete = expanded.delete) !== null && _expanded$delete !== void 0 ? _expanded$delete : emptyFn
+  };
+}
+
+export { merge as a, accessReturnError as b, accessDeniedError as c, filterAccessError as d, extensionError as e, formatKeys as f, expandVoidHooks as g, relationshipError as h, idFieldType as i, limitsExceededError as l, mysql as m, postgresql as p, resolverError as r, sqlite as s, userInputError as u, validationFailureError as v };