@nixxie-cms/core 1.0.0

package/dist/index-ac01583b.cjs.js

@@ -0,0 +1,425 @@
+'use strict';
+
+require('pluralize');
+var nextFields = require('./next-fields-49c025ef.cjs.js');
+var resolveHooks = require('./resolve-hooks-66fe8a8e.cjs.js');
+var nonNullGraphql = require('./non-null-graphql-17b83ddc.cjs.js');
+require('node:path');
+require('@graphql-ts/schema');
+require('@graphql-ts/extend');
+var adminMeta = require('./admin-meta-18d0c276.cjs.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: resolveHooks.postgresql,
+  sqlite: resolveHooks.sqlite,
+  mysql: resolveHooks.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 {
+        nextFields.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' ? nextFields.g.DateTime.parseValue(defaultValue) : defaultValue;
+    const {
+      mode,
+      validate
+    } = nonNullGraphql.makeValidateHook(meta, config);
+    return nextFields.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,
+      ...nonNullGraphql.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: nextFields.g.arg({
+            type: nextFields.g.DateTime
+          })
+        } : undefined,
+        where: {
+          arg: nextFields.g.arg({
+            type: filters[meta.provider].DateTime[mode]
+          }),
+          resolve: mode === 'optional' ? resolveCommon : undefined
+        },
+        create: {
+          arg: nextFields.g.arg({
+            type: nextFields.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: nextFields.g.arg({
+            type: nextFields.g.DateTime
+          })
+        },
+        orderBy: {
+          arg: nextFields.g.arg({
+            type: nextFields.orderDirectionEnum
+          })
+        }
+      },
+      output: nextFields.g.field({
+        type: nextFields.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 = adminMeta.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 nextFields.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: nextFields.g.arg({
+              type: foreignListTypes.relateTo.many.where
+            }),
+            resolve(value, _context, resolve) {
+              return resolve(value);
+            }
+          },
+          create: {
+            arg: nextFields.g.arg({
+              type: foreignListTypes.relateTo.many.create
+            }),
+            async resolve(value, _context, resolve) {
+              return resolve(value);
+            }
+          },
+          update: {
+            arg: nextFields.g.arg({
+              type: foreignListTypes.relateTo.many.update
+            }),
+            async resolve(value, _context, resolve) {
+              return resolve(value);
+            }
+          }
+        },
+        output: nextFields.g.field({
+          args: foreignListTypes.findManyArgs,
+          type: nextFields.g.list(nextFields.g.nonNull(foreignListTypes.output)),
+          resolve({
+            value
+          }, args) {
+            return value.findMany(args);
+          }
+        }),
+        extraOutputFields: {
+          [`${fieldKey}Count`]: nextFields.g.field({
+            type: nextFields.g.Int,
+            args: {
+              where: nextFields.g.arg({
+                type: nextFields.g.nonNull(foreignListTypes.where),
+                defaultValue: {}
+              })
+            },
+            resolve({
+              value
+            }, args) {
+              return value.count({
+                where: args.where
+              });
+            }
+          })
+        }
+      });
+    }
+    return nextFields.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: nextFields.g.arg({
+            type: foreignListTypes.where
+          }),
+          resolve(value, _context, resolve) {
+            return resolve(value);
+          }
+        },
+        uniqueWhere: {
+          arg: nextFields.g.arg({
+            type: foreignListTypes.uniqueWhere
+          })
+        },
+        create: foreignListTypes.relateTo.one.create && {
+          arg: nextFields.g.arg({
+            type: foreignListTypes.relateTo.one.create
+          }),
+          async resolve(value, _context, resolve) {
+            return resolve(value);
+          }
+        },
+        update: foreignListTypes.relateTo.one.update && {
+          arg: nextFields.g.arg({
+            type: foreignListTypes.relateTo.one.update
+          }),
+          async resolve(value, _context, resolve) {
+            return resolve(value);
+          }
+        }
+      },
+      output: nextFields.g.field({
+        type: foreignListTypes.output,
+        resolve({
+          value
+        }) {
+          return value();
+        }
+      })
+    });
+  };
+}
+
+exports.filters = filters;
+exports.relationship = relationship;
+exports.resolveCommon = resolveCommon;
+exports.resolveString = resolveString;
+exports.timestamp = timestamp;

package/dist/migrations-996e66a0.esm.js

@@ -0,0 +1,76 @@
+import { join, dirname } from 'node:path';
+import { loadSchemaContext, toSchemasContainer } from '@prisma/internals';
+import { Migrate } from '@prisma/migrate';
+
+function setOrRemoveEnvVariable(name, value) {
+  if (value === undefined) {
+    delete process.env[name];
+    return;
+  }
+  process.env[name] = value;
+}
+async function withMigrate(prismaSchemaPath, system, cb) {
+  const schemaContext = await loadSchemaContext({
+    schemaPathFromArg: prismaSchemaPath,
+    printLoadMessage: false,
+    ignoreEnvVarErrors: true
+  });
+  const migrate = await Migrate.setup({
+    schemaContext,
+    migrationsDirPath: join(dirname(prismaSchemaPath), 'migrations')
+  });
+  async function run(f) {
+    // only required once - on child process start - but easiest to do this always
+    const prevDBURLFromEnv = process.env.DATABASE_URL;
+    const prevShadowDBURLFromEnv = process.env.SHADOW_DATABASE_URL;
+    const prevHiddenUpdateMessage = process.env.PRISMA_HIDE_UPDATE_MESSAGE;
+    try {
+      process.env.DATABASE_URL = system.config.db.url;
+      setOrRemoveEnvVariable('SHADOW_DATABASE_URL', system.config.db.shadowDatabaseUrl);
+      process.env.PRISMA_HIDE_UPDATE_MESSAGE = '1'; // temporarily silence
+      return await f();
+    } finally {
+      setOrRemoveEnvVariable('DATABASE_URL', prevDBURLFromEnv);
+      setOrRemoveEnvVariable('SHADOW_DATABASE_URL', prevShadowDBURLFromEnv);
+      setOrRemoveEnvVariable('PRISMA_HIDE_UPDATE_MESSAGE', prevHiddenUpdateMessage);
+    }
+  }
+  try {
+    return await cb({
+      async apply() {
+        return run(() => migrate.applyMigrations());
+      },
+      async diagnostic() {
+        return run(() => migrate.devDiagnostic());
+      },
+      async push(force) {
+        return run(() => migrate.push({
+          force
+        }));
+      },
+      async reset() {
+        return run(() => migrate.reset());
+      },
+      async schema(schema, force) {
+        const schemaContainer = toSchemasContainer([[prismaSchemaPath, schema]]);
+        return run(() => migrate.engine.schemaPush({
+          force,
+          schema: schemaContainer,
+          filters: {
+            externalEnums: [],
+            externalTables: []
+          }
+        }));
+      }
+    });
+  } finally {
+    await migrate.engine.initPromise;
+    const closePromise = new Promise(resolve => {
+      migrate.engine.child.once('exit', resolve);
+    });
+    migrate.stop();
+    await closePromise;
+  }
+}
+
+export { withMigrate as w };

package/dist/migrations-ab2e0fd4.cjs.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var path = require('node:path');
+var internals = require('@prisma/internals');
+var migrate = require('@prisma/migrate');
+
+function setOrRemoveEnvVariable(name, value) {
+  if (value === undefined) {
+    delete process.env[name];
+    return;
+  }
+  process.env[name] = value;
+}
+async function withMigrate(prismaSchemaPath, system, cb) {
+  const schemaContext = await internals.loadSchemaContext({
+    schemaPathFromArg: prismaSchemaPath,
+    printLoadMessage: false,
+    ignoreEnvVarErrors: true
+  });
+  const migrate$1 = await migrate.Migrate.setup({
+    schemaContext,
+    migrationsDirPath: path.join(path.dirname(prismaSchemaPath), 'migrations')
+  });
+  async function run(f) {
+    // only required once - on child process start - but easiest to do this always
+    const prevDBURLFromEnv = process.env.DATABASE_URL;
+    const prevShadowDBURLFromEnv = process.env.SHADOW_DATABASE_URL;
+    const prevHiddenUpdateMessage = process.env.PRISMA_HIDE_UPDATE_MESSAGE;
+    try {
+      process.env.DATABASE_URL = system.config.db.url;
+      setOrRemoveEnvVariable('SHADOW_DATABASE_URL', system.config.db.shadowDatabaseUrl);
+      process.env.PRISMA_HIDE_UPDATE_MESSAGE = '1'; // temporarily silence
+      return await f();
+    } finally {
+      setOrRemoveEnvVariable('DATABASE_URL', prevDBURLFromEnv);
+      setOrRemoveEnvVariable('SHADOW_DATABASE_URL', prevShadowDBURLFromEnv);
+      setOrRemoveEnvVariable('PRISMA_HIDE_UPDATE_MESSAGE', prevHiddenUpdateMessage);
+    }
+  }
+  try {
+    return await cb({
+      async apply() {
+        return run(() => migrate$1.applyMigrations());
+      },
+      async diagnostic() {
+        return run(() => migrate$1.devDiagnostic());
+      },
+      async push(force) {
+        return run(() => migrate$1.push({
+          force
+        }));
+      },
+      async reset() {
+        return run(() => migrate$1.reset());
+      },
+      async schema(schema, force) {
+        const schemaContainer = internals.toSchemasContainer([[prismaSchemaPath, schema]]);
+        return run(() => migrate$1.engine.schemaPush({
+          force,
+          schema: schemaContainer,
+          filters: {
+            externalEnums: [],
+            externalTables: []
+          }
+        }));
+      }
+    });
+  } finally {
+    await migrate$1.engine.initPromise;
+    const closePromise = new Promise(resolve => {
+      migrate$1.engine.child.once('exit', resolve);
+    });
+    migrate$1.stop();
+    await closePromise;
+  }
+}
+
+exports.withMigrate = withMigrate;