@nixxie-cms/core 1.0.0

package/dist/index-24b78415.esm.js

@@ -0,0 +1,419 @@
+import 'pluralize';
+import { g, f as fieldType, o as orderDirectionEnum } from './next-fields-9bf04ed8.esm.js';
+import { p as postgresql, s as sqlite, m as mysql } from './resolve-hooks-17aafd37.esm.js';
+import { m as makeValidateHook, d as defaultIsRequired } from './non-null-graphql-5315718c.esm.js';
+import 'node:path';
+import '@graphql-ts/schema';
+import '@graphql-ts/extend';
+import { g as getAdminMetaForRelationshipField } from './admin-meta-14c60fec.esm.js';
+
+const objectEntriesButAssumeNoExtraProperties = Object.entries;
+function internalResolveFilter(entries, mode) {
+  const entry = entries.shift();
+  if (entry === undefined) return {};
+  const [key, val] = entry;
+  if (val == null) {
+    return {
+      AND: [{
+        [key]: val
+      }, internalResolveFilter(entries, mode)]
+    };
+  }
+  switch (key) {
+    case 'equals':
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte':
+    case 'in':
+    case 'contains':
+    case 'startsWith':
+    case 'endsWith':
+      {
+        return {
+          AND: [{
+            [key]: val,
+            mode
+          }, {
+            not: null
+          }, internalResolveFilter(entries, mode)]
+        };
+      }
+    case 'notIn':
+      {
+        return {
+          AND: [{
+            NOT: [internalResolveFilter(objectEntriesButAssumeNoExtraProperties({
+              in: val
+            }), mode)]
+          }, internalResolveFilter(entries, mode)]
+        };
+      }
+    case 'not':
+      {
+        return {
+          AND: [{
+            NOT: [internalResolveFilter(objectEntriesButAssumeNoExtraProperties(val), mode)]
+          }, internalResolveFilter(entries, mode)]
+        };
+      }
+  }
+}
+function resolveCommon(val) {
+  if (val === null) return null;
+  return internalResolveFilter(objectEntriesButAssumeNoExtraProperties(val), undefined);
+}
+function resolveString(val) {
+  if (val === null) return null;
+  const {
+    mode,
+    ...value
+  } = val;
+  return internalResolveFilter(objectEntriesButAssumeNoExtraProperties(value), mode !== null && mode !== void 0 ? mode : undefined);
+}
+
+var filters = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  postgresql: postgresql,
+  sqlite: sqlite,
+  mysql: mysql,
+  resolveCommon: resolveCommon,
+  resolveString: resolveString
+});
+
+function timestamp(config = {}) {
+  const {
+    isIndexed,
+    defaultValue,
+    validation
+  } = config;
+  return meta => {
+    var _config$db, _config$db2, _config$db3, _validation$isRequire;
+    if (typeof defaultValue === 'string') {
+      try {
+        g.DateTime.parseValue(defaultValue);
+      } catch (err) {
+        throw new Error(`${meta.listKey}.${meta.fieldKey}.defaultValue is required to be an ISO8601 date-time string such as ${new Date().toISOString()}`);
+      }
+    }
+    const parsedDefaultValue = typeof defaultValue === 'string' ? g.DateTime.parseValue(defaultValue) : defaultValue;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config);
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'DateTime',
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: typeof defaultValue === 'string' ? {
+        kind: 'literal',
+        value: defaultValue
+      } : defaultValue === undefined ? undefined : {
+        kind: 'now'
+      },
+      updatedAt: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.updatedAt,
+      map: (_config$db2 = config.db) === null || _config$db2 === void 0 ? void 0 : _config$db2.map,
+      extendPrismaSchema: (_config$db3 = config.db) === null || _config$db3 === void 0 ? void 0 : _config$db3.extendPrismaSchema
+    })({
+      ...config,
+      ...defaultIsRequired(config, (_validation$isRequire = validation === null || validation === void 0 ? void 0 : validation.isRequired) !== null && _validation$isRequire !== void 0 ? _validation$isRequire : false),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.DateTime
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].DateTime[mode]
+          }),
+          resolve: mode === 'optional' ? resolveCommon : undefined
+        },
+        create: {
+          arg: g.arg({
+            type: g.DateTime,
+            // TODO: add support for defaultValue of { kind: 'now' } in the GraphQL API
+            defaultValue: parsedDefaultValue instanceof Date ? parsedDefaultValue : undefined
+          }),
+          resolve(val) {
+            if (val === undefined) {
+              var _config$db4;
+              if (parsedDefaultValue === undefined && (_config$db4 = config.db) !== null && _config$db4 !== void 0 && _config$db4.updatedAt) return undefined;
+              if (parsedDefaultValue instanceof Date || parsedDefaultValue === undefined) {
+                return parsedDefaultValue !== null && parsedDefaultValue !== void 0 ? parsedDefaultValue : null;
+              }
+              return new Date();
+            }
+            return val;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.DateTime
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.DateTime
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/timestamp',
+      views: '@nixxie-cms/core/fields/types/timestamp/views',
+      getAdminMeta() {
+        var _config$db$updatedAt, _config$db5;
+        return {
+          defaultValue: defaultValue !== null && defaultValue !== void 0 ? defaultValue : null,
+          updatedAt: (_config$db$updatedAt = (_config$db5 = config.db) === null || _config$db5 === void 0 ? void 0 : _config$db5.updatedAt) !== null && _config$db$updatedAt !== void 0 ? _config$db$updatedAt : false
+        };
+      }
+    });
+  };
+}
+
+// This is the default display mode for Relationships
+
+function throwIfMissingFields(localListMeta, foreignListMeta, refLabelField, refSearchFields, fieldKey) {
+  if (!(refLabelField in foreignListMeta.fieldsByKey)) {
+    throw new Error(`"${refLabelField}" is not a field of list "${foreignListMeta.key}", configured as labelField for "${localListMeta.key}.${fieldKey}"`);
+  }
+  for (const searchFieldKey of refSearchFields) {
+    const field = foreignListMeta.fieldsByKey[searchFieldKey];
+    if (!field) throw new Error(`"${searchFieldKey}" is not a field of list "${foreignListMeta.key}", configured as searchField for "${localListMeta.key}.${fieldKey}"`);
+    if (field.search === null) throw new Error(`"${searchFieldKey}" is not a searchable field of list "${foreignListMeta.key}", configured as searchField for "${localListMeta.key}.${fieldKey}"`);
+  }
+}
+
+// TODO: add types based on list types
+
+function relationship({
+  ref,
+  ...config
+}) {
+  const {
+    many = false
+  } = config;
+  const [foreignListKey, foreignFieldKey] = ref.split('.');
+  return ({
+    fieldKey,
+    listKey,
+    lists
+  }) => {
+    var _config$db3, _config$db4;
+    const foreignList = lists[foreignListKey];
+    if (!foreignList) throw new Error(`${listKey}.${fieldKey} points to ${ref}, but ${ref} doesn't exist`);
+    const foreignListTypes = foreignList.types;
+    const commonConfig = {
+      ...config,
+      __ksTelemetryFieldTypeName: '@nixxie-cms/relationship',
+      views: '@nixxie-cms/core/fields/types/relationship/views',
+      getAdminMeta: () => {
+        var _config$ui$hideCreate, _config$ui, _config$ui2, _config$ui3, _config$ui$labelField, _config$ui4, _config$ui$searchFiel, _config$ui5, _config$ui$filter, _config$ui6, _ref2, _config$ui$sort, _config$ui7;
+        const adminMetaRoot = getAdminMetaForRelationshipField();
+        const localListMeta = adminMetaRoot.listsByKey[listKey];
+        const foreignListMeta = adminMetaRoot.listsByKey[foreignListKey];
+        if (!foreignListMeta) {
+          throw new Error(`The ref [${ref}] on relationship [${listKey}.${fieldKey}] is invalid`);
+        }
+        const refLabelField = foreignListMeta.labelField;
+        const refSearchFields = foreignListMeta.initialSearchFields;
+        const hasOmittedCreate = !lists[foreignListKey].types.relateTo[many ? 'many' : 'one'].create.getFields().create;
+        const hideCreate = (_config$ui$hideCreate = (_config$ui = config.ui) === null || _config$ui === void 0 ? void 0 : _config$ui.hideCreate) !== null && _config$ui$hideCreate !== void 0 ? _config$ui$hideCreate : hasOmittedCreate;
+        if (!hideCreate && hasOmittedCreate) {
+          throw new Error(`${listKey}.${fieldKey} has ui.hideCreate: false, but the related list ${foreignListKey} has graphql.omit.create: true`);
+        }
+        if (((_config$ui2 = config.ui) === null || _config$ui2 === void 0 ? void 0 : _config$ui2.displayMode) === 'count') {
+          var _config$ui$itemView;
+          if (((_config$ui$itemView = config.ui.itemView) === null || _config$ui$itemView === void 0 ? void 0 : _config$ui$itemView.fieldMode) !== 'read') {
+            throw new Error(`displayMode: 'count' on relationship fields requires itemView.fieldMode to be 'read' but ${listKey}.${fieldKey} does not have this set`);
+          }
+          return {
+            displayMode: 'count',
+            refListKey: foreignListKey,
+            refFieldKey: foreignFieldKey,
+            many,
+            hideCreate,
+            refLabelField,
+            refSearchFields
+          };
+        }
+        if (((_config$ui3 = config.ui) === null || _config$ui3 === void 0 ? void 0 : _config$ui3.displayMode) === 'table') {
+          var _config$ui$itemView2, _ref, _config$ui$initialSor, _config$ui$columns2;
+          if (!foreignFieldKey) {
+            throw new Error(`Using a two-sided relationship (\`ref\` must specify "List.fieldKey", not just "List") is required when using displayMode: 'table' for relationship fields but ${listKey}.${fieldKey} has \`ref: ${JSON.stringify(ref)}\``);
+          }
+          if (((_config$ui$itemView2 = config.ui.itemView) === null || _config$ui$itemView2 === void 0 ? void 0 : _config$ui$itemView2.fieldMode) !== 'read') {
+            throw new Error(`displayMode: 'table' on relationship fields currently requires itemView.fieldMode to be 'read' but ${listKey}.${fieldKey} does not have this set`);
+          }
+          for (const key of (_config$ui$columns = config.ui.columns) !== null && _config$ui$columns !== void 0 ? _config$ui$columns : []) {
+            var _config$ui$columns;
+            if (!(key in foreignListMeta.fieldsByKey)) {
+              throw new Error(`The field "${foreignListMeta.key}.${key}" does not exist, configured as a column for "${localListMeta.key}.${fieldKey}"`);
+            }
+          }
+          if (config.ui.initialSort) {
+            const field = foreignListMeta.fieldsByKey[config.ui.initialSort.field];
+            if (!field) {
+              throw new Error(`The field "${foreignListMeta.key}.${config.ui.initialSort.field}" does not exist, configured as the initialSort field for "${localListMeta.key}.${fieldKey}"`);
+            }
+            if (!field.isOrderable) {
+              throw new Error(`The field "${foreignListMeta.key}.${config.ui.initialSort.field}" is not orderable, configured as the initialSort field for "${localListMeta.key}.${fieldKey}"`);
+            }
+          }
+          return {
+            displayMode: 'table',
+            refListKey: foreignListKey,
+            refFieldKey: foreignFieldKey,
+            initialSort: (_ref = (_config$ui$initialSor = config.ui.initialSort) !== null && _config$ui$initialSor !== void 0 ? _config$ui$initialSor : foreignListMeta.initialSort) !== null && _ref !== void 0 ? _ref : null,
+            columns: (_config$ui$columns2 = config.ui.columns) !== null && _config$ui$columns2 !== void 0 ? _config$ui$columns2 : null,
+            many,
+            hideCreate,
+            refLabelField,
+            refSearchFields
+          };
+        }
+
+        // prefer the local definition to the foreign list, if provided
+        const specificRefLabelField = (_config$ui$labelField = (_config$ui4 = config.ui) === null || _config$ui4 === void 0 ? void 0 : _config$ui4.labelField) !== null && _config$ui$labelField !== void 0 ? _config$ui$labelField : refLabelField;
+        const specificRefSearchFields = (_config$ui$searchFiel = (_config$ui5 = config.ui) === null || _config$ui5 === void 0 ? void 0 : _config$ui5.searchFields) !== null && _config$ui$searchFiel !== void 0 ? _config$ui$searchFiel : refSearchFields;
+        throwIfMissingFields(localListMeta, foreignListMeta, specificRefLabelField, specificRefSearchFields, fieldKey);
+        return {
+          displayMode: 'select',
+          refListKey: foreignListKey,
+          refFieldKey: foreignFieldKey,
+          many,
+          hideCreate,
+          refLabelField: specificRefLabelField,
+          refSearchFields: specificRefSearchFields,
+          filter: (_config$ui$filter = (_config$ui6 = config.ui) === null || _config$ui6 === void 0 ? void 0 : _config$ui6.filter) !== null && _config$ui$filter !== void 0 ? _config$ui$filter : null,
+          sort: (_ref2 = (_config$ui$sort = (_config$ui7 = config.ui) === null || _config$ui7 === void 0 ? void 0 : _config$ui7.sort) !== null && _config$ui$sort !== void 0 ? _config$ui$sort : foreignListMeta.initialSort) !== null && _ref2 !== void 0 ? _ref2 : null
+        };
+      }
+    };
+    if (config.many) {
+      var _config$db, _config$db2;
+      return fieldType({
+        kind: 'relation',
+        mode: 'many',
+        list: foreignListKey,
+        field: foreignFieldKey,
+        relationName: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.relationName,
+        extendPrismaSchema: (_config$db2 = config.db) === null || _config$db2 === void 0 ? void 0 : _config$db2.extendPrismaSchema
+      })({
+        ...commonConfig,
+        input: {
+          where: {
+            arg: g.arg({
+              type: foreignListTypes.relateTo.many.where
+            }),
+            resolve(value, _context, resolve) {
+              return resolve(value);
+            }
+          },
+          create: {
+            arg: g.arg({
+              type: foreignListTypes.relateTo.many.create
+            }),
+            async resolve(value, _context, resolve) {
+              return resolve(value);
+            }
+          },
+          update: {
+            arg: g.arg({
+              type: foreignListTypes.relateTo.many.update
+            }),
+            async resolve(value, _context, resolve) {
+              return resolve(value);
+            }
+          }
+        },
+        output: g.field({
+          args: foreignListTypes.findManyArgs,
+          type: g.list(g.nonNull(foreignListTypes.output)),
+          resolve({
+            value
+          }, args) {
+            return value.findMany(args);
+          }
+        }),
+        extraOutputFields: {
+          [`${fieldKey}Count`]: g.field({
+            type: g.Int,
+            args: {
+              where: g.arg({
+                type: g.nonNull(foreignListTypes.where),
+                defaultValue: {}
+              })
+            },
+            resolve({
+              value
+            }, args) {
+              return value.count({
+                where: args.where
+              });
+            }
+          })
+        }
+      });
+    }
+    return fieldType({
+      kind: 'relation',
+      mode: 'one',
+      list: foreignListKey,
+      field: foreignFieldKey,
+      foreignKey: (_config$db3 = config.db) === null || _config$db3 === void 0 ? void 0 : _config$db3.foreignKey,
+      extendPrismaSchema: (_config$db4 = config.db) === null || _config$db4 === void 0 ? void 0 : _config$db4.extendPrismaSchema
+    })({
+      ...commonConfig,
+      input: {
+        where: {
+          arg: g.arg({
+            type: foreignListTypes.where
+          }),
+          resolve(value, _context, resolve) {
+            return resolve(value);
+          }
+        },
+        uniqueWhere: {
+          arg: g.arg({
+            type: foreignListTypes.uniqueWhere
+          })
+        },
+        create: foreignListTypes.relateTo.one.create && {
+          arg: g.arg({
+            type: foreignListTypes.relateTo.one.create
+          }),
+          async resolve(value, _context, resolve) {
+            return resolve(value);
+          }
+        },
+        update: foreignListTypes.relateTo.one.update && {
+          arg: g.arg({
+            type: foreignListTypes.relateTo.one.update
+          }),
+          async resolve(value, _context, resolve) {
+            return resolve(value);
+          }
+        }
+      },
+      output: g.field({
+        type: foreignListTypes.output,
+        resolve({
+          value
+        }) {
+          return value();
+        }
+      })
+    });
+  };
+}
+
+export { resolveCommon as a, resolveString as b, filters as f, relationship as r, timestamp as t };