@nixxie-cms/core 1.0.0

package/dist/next-fields-49c025ef.cjs.js

@@ -0,0 +1,251 @@
+'use strict';
+
+var Decimal$1 = require('decimal.js');
+var schema = require('@graphql-ts/schema');
+var extend = require('@graphql-ts/extend');
+var GraphQLUpload = require('graphql-upload/GraphQLUpload.js');
+var graphql = require('graphql');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var GraphQLUpload__default = /*#__PURE__*/_interopDefault(GraphQLUpload);
+
+// @ts-expect-error
+const JSON = new graphql.GraphQLScalarType({
+  name: 'JSON',
+  description: 'The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).',
+  specifiedByURL: 'http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf'
+  // the defaults for serialize, parseValue and parseLiteral do what makes sense for JSON
+});
+
+// avoiding using Buffer.from/etc. because we want a plain Uint8Array and that would be an extra conversion
+// when https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex and etc.
+// is available we should use that instead
+
+function hexToBytes(value) {
+  if (!/^[0-9a-fA-F]*$/.test(value)) {
+    throw new graphql.GraphQLError('Hex values must be a string of hexadecimal characters');
+  }
+  if (value.length % 2 !== 0) {
+    throw new graphql.GraphQLError('Hex values must have an even number of characters');
+  }
+  const bytes = new Uint8Array(value.length / 2);
+  for (let i = 0; i < bytes.byteLength; i += 1) {
+    const start = i * 2;
+    bytes[i] = parseInt(value.slice(start, start + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  let str = '';
+  for (const byte of bytes) {
+    str += byte.toString(16).padStart(2, '0');
+  }
+  return str;
+}
+const Hex = new graphql.GraphQLScalarType({
+  name: 'Hex',
+  description: 'The `Hex` scalar type represents bytes as a string of hexadecimal characters.',
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new graphql.GraphQLError('Hex only accepts values as strings');
+    }
+    return hexToBytes(value.value);
+  },
+  parseValue(value) {
+    // so that when you're doing a mutation in a resolver, you can just pass in a Uint8Array directly
+    if (value instanceof Uint8Array) {
+      // duplicate it though to avoid any weirdness with the array being mutated
+      // + ensuring that if you pass in a Buffer, resolvers receive a normal Uint8Array
+      return Uint8Array.from(value);
+    }
+    if (typeof value !== 'string') {
+      throw new graphql.GraphQLError('Hex only accepts values as strings');
+    }
+    return hexToBytes(value);
+  },
+  serialize(value) {
+    if (!(value instanceof Uint8Array)) {
+      throw new graphql.GraphQLError(`unexpected value provided to Hex scalar: ${value}`);
+    }
+    return bytesToHex(value);
+  }
+});
+const Upload = GraphQLUpload__default["default"];
+
+// - Decimal.js throws on invalid inputs
+// - Decimal.js can represent +Infinity and -Infinity, these aren't values in Postgres' decimal,
+//   NaN is but Prisma doesn't support it
+//   .isFinite refers to +Infinity, -Infinity and NaN
+const Decimal = new graphql.GraphQLScalarType({
+  name: 'Decimal',
+  serialize(value) {
+    if (!Decimal$1.Decimal.isDecimal(value)) throw new graphql.GraphQLError(`unexpected value provided to Decimal scalar: ${value}`);
+    const cast = value;
+    if (cast.scaleToPrint !== undefined) return value.toFixed(cast.scaleToPrint);
+    return value.toString();
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') throw new graphql.GraphQLError('Decimal only accepts values as strings');
+    const decimal = new Decimal$1.Decimal(value.value);
+    if (!decimal.isFinite()) throw new graphql.GraphQLError('Decimal values must be finite');
+    return decimal;
+  },
+  parseValue(value) {
+    if (Decimal$1.Decimal.isDecimal(value)) {
+      if (!value.isFinite()) throw new graphql.GraphQLError('Decimal values must be finite');
+      return value;
+    }
+    if (typeof value !== 'string') throw new graphql.GraphQLError('Decimal only accepts values as strings');
+    const decimal = new Decimal$1.Decimal(value);
+    if (!decimal.isFinite()) throw new graphql.GraphQLError('Decimal values must be finite');
+    return decimal;
+  }
+});
+const BigInt = new graphql.GraphQLScalarType({
+  name: 'BigInt',
+  serialize(value) {
+    if (typeof value !== 'bigint') throw new graphql.GraphQLError(`unexpected value provided to BigInt scalar: ${value}`);
+    return value.toString();
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') throw new graphql.GraphQLError('BigInt only accepts values as strings');
+    return globalThis.BigInt(value.value);
+  },
+  parseValue(value) {
+    if (typeof value === 'bigint') return value;
+    if (typeof value !== 'string') throw new graphql.GraphQLError('BigInt only accepts values as strings');
+    return globalThis.BigInt(value);
+  }
+});
+
+// from https://github.com/excitement-engineer/graphql-iso-date/blob/master/src/utils/validator.js#L121
+// this is also what prisma uses https://github.com/prisma/prisma/blob/20b58fe65d581bcb43c0d5c28d4b89cabc2d99b2/packages/client/src/runtime/utils/common.ts#L126-L128
+const RFC_3339_REGEX = /^(\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60))(\.\d{1,})?(([Z])|([+|-]([01][0-9]|2[0-3]):[0-5][0-9]))$/;
+function parseDate(input) {
+  if (!RFC_3339_REGEX.test(input)) {
+    throw new graphql.GraphQLError('DateTime scalars must be in the form of a full ISO 8601 date-time string');
+  }
+  const parsed = new Date(input);
+  if (isNaN(parsed.valueOf())) {
+    throw new graphql.GraphQLError('DateTime scalars must be in the form of a full ISO 8601 date-time string');
+  }
+  return parsed;
+}
+const DateTime = new graphql.GraphQLScalarType({
+  name: 'DateTime',
+  specifiedByURL: 'https://datatracker.ietf.org/doc/html/rfc3339#section-5.6',
+  serialize(value) {
+    if (!(value instanceof Date) || isNaN(value.valueOf())) {
+      throw new graphql.GraphQLError(`unexpected value provided to DateTime scalar: ${value}`);
+    }
+    return value.toISOString();
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new graphql.GraphQLError('DateTime only accepts values as strings');
+    }
+    return parseDate(value.value);
+  },
+  parseValue(value) {
+    if (value instanceof Date) return value;
+    if (typeof value !== 'string') {
+      throw new graphql.GraphQLError('DateTime only accepts values as strings');
+    }
+    return parseDate(value);
+  }
+});
+const RFC_3339_FULL_DATE_REGEX = /^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$/;
+function validateCalendarDay(input) {
+  if (!RFC_3339_FULL_DATE_REGEX.test(input)) {
+    throw new graphql.GraphQLError('CalendarDay scalars must be in the form of a full-date ISO 8601 string');
+  }
+}
+const CalendarDay = new graphql.GraphQLScalarType({
+  name: 'CalendarDay',
+  specifiedByURL: 'https://datatracker.ietf.org/doc/html/rfc3339#section-5.6',
+  serialize(value) {
+    if (typeof value !== 'string') {
+      throw new graphql.GraphQLError(`unexpected value provided to CalendarDay scalar: ${value}`);
+    }
+    return value;
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new graphql.GraphQLError('CalendarDay only accepts values as strings');
+    }
+    validateCalendarDay(value.value);
+    return value.value;
+  },
+  parseValue(value) {
+    if (typeof value !== 'string') {
+      throw new graphql.GraphQLError('CalendarDay only accepts values as strings');
+    }
+    validateCalendarDay(value);
+    return value;
+  }
+});
+const Empty = new graphql.GraphQLScalarType({
+  name: 'Empty',
+  serialize(value) {
+    return null;
+  },
+  parseLiteral(value) {
+    return {};
+  },
+  parseValue(value) {
+    return {};
+  }
+});
+
+var scalars = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  JSON: JSON,
+  Hex: Hex,
+  Upload: Upload,
+  Decimal: Decimal,
+  BigInt: BigInt,
+  DateTime: DateTime,
+  CalendarDay: CalendarDay,
+  Empty: Empty
+});
+
+function gWithContext() {
+  return {
+    ...schema.gWithContext(),
+    ...scalars,
+    extend: extend.extend
+  };
+}
+
+const g = gWithContext();
+
+const orderDirectionEnum = g.enum({
+  name: 'OrderDirection',
+  values: g.enumValues(['asc', 'desc'])
+});
+const QueryMode = g.enum({
+  name: 'QueryMode',
+  values: g.enumValues(['default', 'insensitive'])
+});
+
+// TODO: merge
+
+// TODO: this isn't right for create
+// for create though, db level defaults need to be taken into account for when to not allow undefined
+
+// fieldType(dbField)(fieldInfo) => { ...fieldInfo, dbField };
+function fieldType(dbField) {
+  return function fieldTypeWrapper(graphQLInfo) {
+    return {
+      ...graphQLInfo,
+      dbField
+    };
+  };
+}
+
+exports.QueryMode = QueryMode;
+exports.fieldType = fieldType;
+exports.g = g;
+exports.gWithContext = gWithContext;
+exports.orderDirectionEnum = orderDirectionEnum;

package/dist/next-fields-9bf04ed8.esm.js

@@ -0,0 +1,241 @@
+import { Decimal as Decimal$1 } from 'decimal.js';
+import { gWithContext as gWithContext$1 } from '@graphql-ts/schema';
+import { extend } from '@graphql-ts/extend';
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js';
+import { GraphQLScalarType, GraphQLError } from 'graphql';
+
+// @ts-expect-error
+const JSON = new GraphQLScalarType({
+  name: 'JSON',
+  description: 'The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).',
+  specifiedByURL: 'http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf'
+  // the defaults for serialize, parseValue and parseLiteral do what makes sense for JSON
+});
+
+// avoiding using Buffer.from/etc. because we want a plain Uint8Array and that would be an extra conversion
+// when https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex and etc.
+// is available we should use that instead
+
+function hexToBytes(value) {
+  if (!/^[0-9a-fA-F]*$/.test(value)) {
+    throw new GraphQLError('Hex values must be a string of hexadecimal characters');
+  }
+  if (value.length % 2 !== 0) {
+    throw new GraphQLError('Hex values must have an even number of characters');
+  }
+  const bytes = new Uint8Array(value.length / 2);
+  for (let i = 0; i < bytes.byteLength; i += 1) {
+    const start = i * 2;
+    bytes[i] = parseInt(value.slice(start, start + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  let str = '';
+  for (const byte of bytes) {
+    str += byte.toString(16).padStart(2, '0');
+  }
+  return str;
+}
+const Hex = new GraphQLScalarType({
+  name: 'Hex',
+  description: 'The `Hex` scalar type represents bytes as a string of hexadecimal characters.',
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new GraphQLError('Hex only accepts values as strings');
+    }
+    return hexToBytes(value.value);
+  },
+  parseValue(value) {
+    // so that when you're doing a mutation in a resolver, you can just pass in a Uint8Array directly
+    if (value instanceof Uint8Array) {
+      // duplicate it though to avoid any weirdness with the array being mutated
+      // + ensuring that if you pass in a Buffer, resolvers receive a normal Uint8Array
+      return Uint8Array.from(value);
+    }
+    if (typeof value !== 'string') {
+      throw new GraphQLError('Hex only accepts values as strings');
+    }
+    return hexToBytes(value);
+  },
+  serialize(value) {
+    if (!(value instanceof Uint8Array)) {
+      throw new GraphQLError(`unexpected value provided to Hex scalar: ${value}`);
+    }
+    return bytesToHex(value);
+  }
+});
+const Upload = GraphQLUpload;
+
+// - Decimal.js throws on invalid inputs
+// - Decimal.js can represent +Infinity and -Infinity, these aren't values in Postgres' decimal,
+//   NaN is but Prisma doesn't support it
+//   .isFinite refers to +Infinity, -Infinity and NaN
+const Decimal = new GraphQLScalarType({
+  name: 'Decimal',
+  serialize(value) {
+    if (!Decimal$1.isDecimal(value)) throw new GraphQLError(`unexpected value provided to Decimal scalar: ${value}`);
+    const cast = value;
+    if (cast.scaleToPrint !== undefined) return value.toFixed(cast.scaleToPrint);
+    return value.toString();
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') throw new GraphQLError('Decimal only accepts values as strings');
+    const decimal = new Decimal$1(value.value);
+    if (!decimal.isFinite()) throw new GraphQLError('Decimal values must be finite');
+    return decimal;
+  },
+  parseValue(value) {
+    if (Decimal$1.isDecimal(value)) {
+      if (!value.isFinite()) throw new GraphQLError('Decimal values must be finite');
+      return value;
+    }
+    if (typeof value !== 'string') throw new GraphQLError('Decimal only accepts values as strings');
+    const decimal = new Decimal$1(value);
+    if (!decimal.isFinite()) throw new GraphQLError('Decimal values must be finite');
+    return decimal;
+  }
+});
+const BigInt = new GraphQLScalarType({
+  name: 'BigInt',
+  serialize(value) {
+    if (typeof value !== 'bigint') throw new GraphQLError(`unexpected value provided to BigInt scalar: ${value}`);
+    return value.toString();
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') throw new GraphQLError('BigInt only accepts values as strings');
+    return globalThis.BigInt(value.value);
+  },
+  parseValue(value) {
+    if (typeof value === 'bigint') return value;
+    if (typeof value !== 'string') throw new GraphQLError('BigInt only accepts values as strings');
+    return globalThis.BigInt(value);
+  }
+});
+
+// from https://github.com/excitement-engineer/graphql-iso-date/blob/master/src/utils/validator.js#L121
+// this is also what prisma uses https://github.com/prisma/prisma/blob/20b58fe65d581bcb43c0d5c28d4b89cabc2d99b2/packages/client/src/runtime/utils/common.ts#L126-L128
+const RFC_3339_REGEX = /^(\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60))(\.\d{1,})?(([Z])|([+|-]([01][0-9]|2[0-3]):[0-5][0-9]))$/;
+function parseDate(input) {
+  if (!RFC_3339_REGEX.test(input)) {
+    throw new GraphQLError('DateTime scalars must be in the form of a full ISO 8601 date-time string');
+  }
+  const parsed = new Date(input);
+  if (isNaN(parsed.valueOf())) {
+    throw new GraphQLError('DateTime scalars must be in the form of a full ISO 8601 date-time string');
+  }
+  return parsed;
+}
+const DateTime = new GraphQLScalarType({
+  name: 'DateTime',
+  specifiedByURL: 'https://datatracker.ietf.org/doc/html/rfc3339#section-5.6',
+  serialize(value) {
+    if (!(value instanceof Date) || isNaN(value.valueOf())) {
+      throw new GraphQLError(`unexpected value provided to DateTime scalar: ${value}`);
+    }
+    return value.toISOString();
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new GraphQLError('DateTime only accepts values as strings');
+    }
+    return parseDate(value.value);
+  },
+  parseValue(value) {
+    if (value instanceof Date) return value;
+    if (typeof value !== 'string') {
+      throw new GraphQLError('DateTime only accepts values as strings');
+    }
+    return parseDate(value);
+  }
+});
+const RFC_3339_FULL_DATE_REGEX = /^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$/;
+function validateCalendarDay(input) {
+  if (!RFC_3339_FULL_DATE_REGEX.test(input)) {
+    throw new GraphQLError('CalendarDay scalars must be in the form of a full-date ISO 8601 string');
+  }
+}
+const CalendarDay = new GraphQLScalarType({
+  name: 'CalendarDay',
+  specifiedByURL: 'https://datatracker.ietf.org/doc/html/rfc3339#section-5.6',
+  serialize(value) {
+    if (typeof value !== 'string') {
+      throw new GraphQLError(`unexpected value provided to CalendarDay scalar: ${value}`);
+    }
+    return value;
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new GraphQLError('CalendarDay only accepts values as strings');
+    }
+    validateCalendarDay(value.value);
+    return value.value;
+  },
+  parseValue(value) {
+    if (typeof value !== 'string') {
+      throw new GraphQLError('CalendarDay only accepts values as strings');
+    }
+    validateCalendarDay(value);
+    return value;
+  }
+});
+const Empty = new GraphQLScalarType({
+  name: 'Empty',
+  serialize(value) {
+    return null;
+  },
+  parseLiteral(value) {
+    return {};
+  },
+  parseValue(value) {
+    return {};
+  }
+});
+
+var scalars = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  JSON: JSON,
+  Hex: Hex,
+  Upload: Upload,
+  Decimal: Decimal,
+  BigInt: BigInt,
+  DateTime: DateTime,
+  CalendarDay: CalendarDay,
+  Empty: Empty
+});
+
+function gWithContext() {
+  return {
+    ...gWithContext$1(),
+    ...scalars,
+    extend
+  };
+}
+
+const g = gWithContext();
+
+const orderDirectionEnum = g.enum({
+  name: 'OrderDirection',
+  values: g.enumValues(['asc', 'desc'])
+});
+const QueryMode = g.enum({
+  name: 'QueryMode',
+  values: g.enumValues(['default', 'insensitive'])
+});
+
+// TODO: merge
+
+// TODO: this isn't right for create
+// for create though, db level defaults need to be taken into account for when to not allow undefined
+
+// fieldType(dbField)(fieldInfo) => { ...fieldInfo, dbField };
+function fieldType(dbField) {
+  return function fieldTypeWrapper(graphQLInfo) {
+    return {
+      ...graphQLInfo,
+      dbField
+    };
+  };
+}
+
+export { QueryMode as Q, gWithContext as a, fieldType as f, g, orderDirectionEnum as o };

package/dist/nixxie-cms-core.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibml4eGllLWNtcy1jb3JlLmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi9kZWNsYXJhdGlvbnMvc3JjL2luZGV4LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==