@smartive/graphql-magic 15.4.0 → 16.0.0

package/migrations/20230912185644_setup.ts

@@ -3,18 +3,18 @@ import { Knex } from 'knex';
 export const up = async (knex: Knex) => {
   await knex.raw(`CREATE TYPE "someEnum" AS ENUM ('A','B','C')`);
 
-  await knex.raw(`CREATE TYPE "role" AS ENUM ('ADMIN','USER')`);
-
   await knex.raw(`CREATE TYPE "reactionType" AS ENUM ('Review','Question','Answer')`);
 
-  await knex.schema.createTable('User', (table) => {
-    table.uuid('id').notNullable().primary();
-    table.string('username', undefined).nullable();
+  await knex.schema.alterTable('User', (table) => {
+    table.string('username', undefined);
+  });
+
+  await knex.schema.alterTable('User', (table) => {
     table.enum('role', null as any, {
       useNative: true,
       existingType: true,
       enumName: 'role',
-    }).nullable();
+    }).nullable().alter();
   });
 
   await knex.schema.createTable('AnotherObject', (table) => {
@@ -101,9 +101,29 @@ export const up = async (knex: Knex) => {
     table.decimal('rating', undefined, undefined).nullable();
   });
 
+  await knex.schema.alterTable('User', (table) => {
+    table.dropColumn('createdAt');
+    table.dropColumn('updatedAt');
+  });
+
 };
 
 export const down = async (knex: Knex) => {
+  await knex.schema.alterTable('User', (table) => {
+    table.timestamp('createdAt');
+    table.timestamp('updatedAt');
+  });
+
+  await knex('User').update({
+    createdAt: 'TODO',
+    updatedAt: 'TODO',
+  });
+
+  await knex.schema.alterTable('User', (table) => {
+    table.timestamp('createdAt').notNullable().alter();
+    table.timestamp('updatedAt').notNullable().alter();
+  });
+
   await knex.schema.dropTable('ReviewRevision');
 
   await knex.schema.dropTable('Review');
@@ -118,10 +138,19 @@ export const down = async (knex: Knex) => {
 
   await knex.schema.dropTable('AnotherObject');
 
-  await knex.schema.dropTable('User');
+  await knex.schema.alterTable('User', (table) => {
+    table.enum('role', null as any, {
+      useNative: true,
+      existingType: true,
+      enumName: 'role',
+    }).notNullable().alter();
+  });
+
+  await knex.schema.alterTable('User', (table) => {
+    table.dropColumn('username');
+  });
 
   await knex.raw('DROP TYPE "reactionType"');
-  await knex.raw('DROP TYPE "role"');
   await knex.raw('DROP TYPE "someEnum"');
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartive/graphql-magic",
-  "version": "15.4.0",
+  "version": "16.0.0",
   "description": "",
   "source": "src/index.ts",
   "type": "module",
@@ -52,13 +52,14 @@
     "@graphql-codegen/typescript-resolvers": "^4.0.1",
     "code-block-writer": "^12.0.0",
     "commander": "^11.0.0",
+    "dayjs": "^1.11.10",
     "dotenv": "^16.3.1",
     "graphql": "^15.8.0",
     "inflection": "^2.0.1",
     "knex": "^3.0.1",
     "knex-schema-inspector": "^3.1.0",
     "lodash": "^4.17.21",
-    "luxon": "^3.3.0",
+    "luxon": "^3.4.4",
     "pg": "^8.11.3",
     "simple-git": "^3.21.0",
     "ts-morph": "^19.0.0",
@@ -73,7 +74,7 @@
     "@types/jest": "29.5.12",
     "@types/lodash": "4.17.0",
     "@types/luxon": "3.4.2",
-    "@types/pg": "8.11.4",
+    "@types/pg": "8.11.5",
     "@types/uuid": "9.0.8",
     "create-ts-index": "1.14.0",
     "del-cli": "5.1.0",
@@ -85,6 +86,6 @@
     "prettier": "2.8.8",
     "ts-jest": "29.1.2",
     "ts-node": "10.9.2",
-    "typescript": "5.4.3"
+    "typescript": "5.4.5"
   }
 }

package/src/bin/gqm/codegen.ts

@@ -1,7 +1,8 @@
 import { generate } from '@graphql-codegen/cli';
+import { DATE_CLASS, DATE_CLASS_IMPORT, DateLibrary } from '../../utils/dates';
 import { ensureDirectoryExists, getSetting } from './settings';
 
-export const generateGraphqlApiTypes = async () => {
+export const generateGraphqlApiTypes = async (dateLibrary: DateLibrary) => {
   const generatedFolderPath = await getSetting('generatedFolderPath');
   await generate({
     overwrite: true,
@@ -9,12 +10,12 @@ export const generateGraphqlApiTypes = async () => {
     documents: undefined,
     generates: {
       [`${generatedFolderPath}/api/index.ts`]: {
-        plugins: ['typescript', 'typescript-resolvers', { add: { content: `import { DateTime } from 'luxon';` } }],
+        plugins: ['typescript', 'typescript-resolvers', { add: { content: DATE_CLASS_IMPORT[dateLibrary] } }],
       },
     },
     config: {
       scalars: {
-        DateTime: 'DateTime',
+        DateTime: DATE_CLASS[dateLibrary],
       },
     },
   });

package/src/bin/gqm/gqm.ts

@@ -12,6 +12,7 @@ import {
   getMigrationDate,
   printSchemaFromModels,
 } from '../..';
+import { DateLibrary } from '../../utils/dates';
 import { generateGraphqlApiTypes, generateGraphqlClientTypes } from './codegen';
 import { parseKnexfile } from './parse-knexfile';
 import { parseModels } from './parse-models';
@@ -37,9 +38,10 @@ program
     const gqlModule = await getSetting('gqlModule');
     writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
     writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
-    writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models));
+    const dateLibrary = (await getSetting('dateLibrary')) as DateLibrary;
+    writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models, dateLibrary));
     writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
-    await generateGraphqlApiTypes();
+    await generateGraphqlApiTypes(dateLibrary);
     await generateGraphqlClientTypes();
   });
 

package/src/bin/gqm/settings.ts

@@ -1,7 +1,16 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
+import { DateLibrary } from '../../utils/dates';
 import { readLine } from './readline';
-import { EMPTY_MODELS, EXECUTE, GET_ME, GITIGNORE, KNEXFILE } from './templates';
+import {
+  EMPTY_MODELS,
+  EXECUTE,
+  GET_ME,
+  GITIGNORE,
+  KNEXFILE,
+  KNEXFILE_DAYJS_TYPE_PARSERS,
+  KNEXFILE_LUXON_TYPE_PARSERS,
+} from './templates';
 
 const SETTINGS_PATH = '.gqmrc.json';
 
@@ -52,6 +61,32 @@ const DEFAULTS = {
   gqlModule: {
     defaultValue: '@smartive/graphql-magic',
   },
+  dateLibrary: {
+    question: 'Which date library to use (dayjs|luxon)?',
+    defaultValue: 'dayjs',
+    init: async (dateLibrary: DateLibrary) => {
+      const knexfilePath = await getSetting('knexfilePath');
+      switch (dateLibrary) {
+        case 'luxon': {
+          const timeZone = await getSetting('timeZone');
+          ensureFileContains(knexfilePath, 'luxon', KNEXFILE_LUXON_TYPE_PARSERS(timeZone));
+          break;
+        }
+        case 'dayjs':
+          ensureFileContains(knexfilePath, 'dayjs', KNEXFILE_DAYJS_TYPE_PARSERS);
+          break;
+        default:
+          throw new Error('Invalid or unsupported date library.');
+      }
+    },
+  },
+  timeZone: {
+    question: 'Which time zone to use?',
+    defaultValue: 'Europe/Zurich',
+    init: () => {
+      // Do nothing
+    },
+  },
 };
 
 type Settings = {
@@ -61,7 +96,7 @@ type Settings = {
 const initSetting = async (name: string) => {
   const { question, defaultValue, init } = DEFAULTS[name];
   const value = (await readLine(`${question} (${defaultValue})`)) || defaultValue;
-  init(value);
+  await init(value);
   return value;
 };
 

package/src/bin/gqm/templates.ts

@@ -17,14 +17,9 @@ const modelDefinitions: ModelDefinitions = [
 export const models = new Models(modelDefinitions);
 `;
 
-export const KNEXFILE = `import { DateTime } from 'luxon';
+export const KNEXFILE = `
 import { types } from 'pg';
 
-const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
-for (const oid of Object.values(dateOids)) {
-  types.setTypeParser(oid, (val) => DateTime.fromSQL(val));
-}
-
 const numberOids = { int8: 20, float8: 701, numeric: 1700 };
 for (const oid of Object.values(numberOids)) {
   types.setTypeParser(oid, Number);
@@ -50,6 +45,24 @@ const knexConfig = {
 export default knexConfig;
 `;
 
+export const KNEXFILE_LUXON_TYPE_PARSERS = (timeZone: string) => `
+import { DateTime } from 'luxon';
+
+const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
+for (const oid of Object.values(dateOids)) {
+  types.setTypeParser(oid, (val) => DateTime.fromSQL(val, { zone: "${timeZone}" }));
+}
+`;
+
+export const KNEXFILE_DAYJS_TYPE_PARSERS = `
+import { dayjs } from 'dayjs';
+
+const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
+for (const oid of Object.values(dateOids)) {
+  types.setTypeParser(oid, (val) => dayjs(val));
+}
+`;
+
 export const GET_ME = `import { gql } from '@smartive/graphql-magic';
 
 export const GET_ME = gql\`
@@ -66,7 +79,6 @@ import knexConfig from "@/knexfile";
 import { Context, User, execute } from "@smartive/graphql-magic";
 import { randomUUID } from "crypto";
 import { knex } from 'knex';
-import { DateTime } from "luxon";
 import { models } from "../config/models";
 
 export const executeGraphql = async <T, V = undefined>(
@@ -89,7 +101,6 @@ export const executeGraphql = async <T, V = undefined>(
     user,
     models: models,
     permissions: { ADMIN: true, UNAUTHENTICATED: true },
-    now: DateTime.local(),
   });
   await db.destroy();
 

package/src/context.ts

@@ -1,18 +1,19 @@
 import { DocumentNode, GraphQLResolveInfo } from 'graphql';
 import { IncomingMessage } from 'http';
 import { Knex } from 'knex';
-import { DateTime } from 'luxon';
 import { Models } from './models/models';
 import { Entity, MutationHook } from './models/mutation-hook';
 import { Permissions } from './permissions/generate';
 import { AliasGenerator } from './resolvers/utils';
+import { AnyDateType } from './utils';
 
 // Minimal user structure required by graphql-magic
 export type User = { id: string; role: string };
 
-export type Context = {
+export type Context<DateType extends AnyDateType = AnyDateType> = {
   req: IncomingMessage;
-  now: DateTime;
+  now: DateType;
+  timeZone?: string;
   knex: Knex;
   document: DocumentNode;
   locale: string;
@@ -20,8 +21,11 @@ export type Context = {
   user?: User;
   models: Models;
   permissions: Permissions;
-  mutationHook?: MutationHook;
+  mutationHook?: MutationHook<DateType>;
   handleUploads?: (data: Entity) => Promise<void>;
 };
 
-export type FullContext = Context & { info: GraphQLResolveInfo; aliases: AliasGenerator };
+export type FullContext = Context & {
+  info: GraphQLResolveInfo;
+  aliases: AliasGenerator;
+};

package/src/db/generate.ts

@@ -1,6 +1,7 @@
 import CodeBlockWriter from 'code-block-writer';
 import { EntityField, get, getColumnName, isCustomField, isInTable, isRootModel, not } from '..';
 import { Models } from '../models/models';
+import { DATE_CLASS, DATE_CLASS_IMPORT, DateLibrary } from '../utils/dates';
 
 const PRIMITIVE_TYPES = {
   ID: 'string',
@@ -9,18 +10,17 @@ const PRIMITIVE_TYPES = {
   Int: 'number',
   Float: 'number',
   String: 'string',
-  DateTime: 'DateTime | string',
 };
 
 const OPTIONAL_SEED_FIELDS = ['createdAt', 'createdById', 'updatedAt', 'updatedById', 'deletedAt', 'deletedById'];
 
-export const generateDBModels = (models: Models) => {
+export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
   const writer: CodeBlockWriter = new CodeBlockWriter['default']({
     useSingleQuote: true,
     indentNumberOfSpaces: 2,
   });
 
-  writer.write(`import { DateTime } from 'luxon';`).blankLine();
+  writer.write(DATE_CLASS_IMPORT[dateLibrary]).blankLine();
 
   for (const enm of models.enums) {
     writer.write(`export type ${enm.name} = ${enm.values.map((v) => `'${v}'`).join(' | ')};`).blankLine();
@@ -36,7 +36,9 @@ export const generateDBModels = (models: Models) => {
       .write(`export type ${model.name} = `)
       .inlineBlock(() => {
         for (const field of fields.filter(not(isCustomField))) {
-          writer.write(`'${getColumnName(field)}': ${getFieldType(field)}${field.nonNull ? '' : ' | null'};`).newLine();
+          writer
+            .write(`'${getColumnName(field)}': ${getFieldType(field, dateLibrary)}${field.nonNull ? '' : ' | null'};`)
+            .newLine();
         }
       })
       .blankLine();
@@ -48,7 +50,9 @@ export const generateDBModels = (models: Models) => {
           writer
             .write(
               `'${getColumnName(field)}'${field.nonNull && field.defaultValue === undefined ? '' : '?'}: ${getFieldType(
-                field
+                field,
+                dateLibrary,
+                true
               )}${field.list ? ' | string' : ''}${field.nonNull ? '' : ' | null'};`
             )
             .newLine();
@@ -62,7 +66,7 @@ export const generateDBModels = (models: Models) => {
         for (const field of fields.filter(not(isCustomField)).filter(isInTable)) {
           writer
             .write(
-              `'${getColumnName(field)}'?: ${getFieldType(field)}${field.list ? ' | string' : ''}${
+              `'${getColumnName(field)}'?: ${getFieldType(field, dateLibrary, true)}${field.list ? ' | string' : ''}${
                 field.nonNull ? '' : ' | null'
               };`
             )
@@ -84,7 +88,7 @@ export const generateDBModels = (models: Models) => {
               .write(
                 `'${getColumnName(field)}'${
                   field.nonNull && field.defaultValue === undefined && !OPTIONAL_SEED_FIELDS.includes(fieldName) ? '' : '?'
-                }: ${field.kind === 'enum' ? (field.list ? 'string[]' : 'string') : getFieldType(field)}${
+                }: ${field.kind === 'enum' ? (field.list ? 'string[]' : 'string') : getFieldType(field, dateLibrary, true)}${
                   field.list ? ' | string' : ''
                 }${field.nonNull ? '' : ' | null'};`
               )
@@ -104,7 +108,7 @@ export const generateDBModels = (models: Models) => {
   return writer.toString();
 };
 
-const getFieldType = (field: EntityField) => {
+const getFieldType = (field: EntityField, dateLibrary: DateLibrary, input?: boolean) => {
   const kind = field.kind;
   switch (kind) {
     case 'json':
@@ -119,6 +123,9 @@ const getFieldType = (field: EntityField) => {
       throw new Error(`Custom fields are not in the db.`);
     case 'primitive':
     case undefined:
+      if (field.type === 'DateTime') {
+        return (input ? `(${DATE_CLASS[dateLibrary]} | string)` : DATE_CLASS[dateLibrary]) + (field.list ? '[]' : '');
+      }
       return get(PRIMITIVE_TYPES, field.type) + (field.list ? '[]' : '');
     default: {
       const exhaustiveCheck: never = kind;

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './models';
 export * from './permissions';
 export * from './resolvers';
 export * from './schema';
+export * from './utils';
 export * from './context';
 export * from './errors';
 export * from './values';

package/src/migrations/generate.ts

@@ -8,6 +8,7 @@ import { EntityField, EntityModel, EnumModel, Models } from '../models/models';
 import {
   and,
   get,
+  isCreatableModel,
   isInherited,
   isUpdatableField,
   isUpdatableModel,
@@ -147,9 +148,7 @@ export class MigrationGenerator {
               .filter(
                 ({ name, ...field }) =>
                   field.kind !== 'custom' &&
-                  !this.columns[model.name].some(
-                    (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
-                  )
+                  !this.getColumn(model.name, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
               ),
             up,
             down
@@ -157,7 +156,7 @@ export class MigrationGenerator {
 
           // Update fields
           const existingFields = model.fields.filter(({ name, kind, nonNull }) => {
-            const col = this.columns[model.name].find((col) => col.name === (kind === 'relation' ? `${name}Id` : name));
+            const col = this.getColumn(model.name, kind === 'relation' ? `${name}Id` : name);
             if (!col) {
               return false;
             }
@@ -216,9 +215,7 @@ export class MigrationGenerator {
               .filter(
                 ({ name, ...field }) =>
                   field.kind !== 'custom' &&
-                  !this.columns[revisionTable].some(
-                    (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
-                  )
+                  !this.getColumn(revisionTable, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
               );
 
             this.createRevisionFields(model, missingRevisionFields, up, down);
@@ -229,9 +226,7 @@ export class MigrationGenerator {
                 field.kind !== 'custom' &&
                 !updatable &&
                 !(field.kind === 'relation' && field.foreignKey === 'id') &&
-                this.columns[revisionTable].some(
-                  (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
-                )
+                this.getColumn(revisionTable, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
             );
             this.createRevisionFields(model, revisionFieldsToRemove, down, up);
           }
@@ -241,12 +236,31 @@ export class MigrationGenerator {
 
     for (const model of models.entities) {
       if (tables.includes(model.name)) {
-        this.createFields(
-          model,
-          model.fields.filter(({ name, deleted }) => deleted && this.columns[model.name].some((col) => col.name === name)),
-          down,
-          up
-        );
+        const fieldsToDelete = model.fields.filter(({ name, deleted }) => deleted && this.getColumn(model.name, name));
+
+        if (!isCreatableModel(model)) {
+          if (this.getColumn(model.name, 'createdAt')) {
+            fieldsToDelete.push({ name: 'createdAt', type: 'DateTime', nonNull: true });
+          }
+
+          if (this.getColumn(model.name, 'createdBy')) {
+            fieldsToDelete.push({ name: 'createdBy', kind: 'relation', type: 'User', nonNull: true });
+          }
+        }
+
+        if (!isUpdatableModel(model)) {
+          if (this.getColumn(model.name, 'updatedAt')) {
+            fieldsToDelete.push({ name: 'updatedAt', type: 'DateTime', nonNull: true });
+          }
+
+          if (this.getColumn(model.name, 'updatedBy')) {
+            fieldsToDelete.push({ name: 'updatedBy', kind: 'relation', type: 'User', nonNull: true });
+          }
+        }
+
+        if (fieldsToDelete.length) {
+          this.createFields(model, fieldsToDelete, down, up);
+        }
 
         if (isUpdatableModel(model)) {
           this.createRevisionFields(
@@ -664,6 +678,10 @@ export class MigrationGenerator {
       }
     }
   }
+
+  private getColumn(tableName: string, columnName: string) {
+    return this.columns[tableName].find((col) => col.name === columnName);
+  }
 }
 
 export const getMigrationDate = () => {

package/src/models/mutation-hook.ts

@@ -1,17 +1,14 @@
-import { DateTime } from 'luxon';
-import { Context } from '..';
+import { AnyDateType, Context } from '..';
 import { EntityModel } from './models';
 
-export type Entity = Record<string, unknown> & { createdAt?: DateTime; deletedAt?: DateTime };
-
-export type FullEntity = Entity & { id: string };
+export type Entity = Record<string, unknown>;
 
 export type Action = 'create' | 'update' | 'delete' | 'restore';
 
-export type MutationHook = (
+export type MutationHook<DateType extends AnyDateType = AnyDateType> = (
   model: EntityModel,
   action: Action,
   when: 'before' | 'after',
-  data: { prev: Entity; input: Entity; normalizedInput: Entity; next: FullEntity },
-  ctx: Context
+  data: { prev: Entity; input: Entity; normalizedInput: Entity; next: Entity },
+  ctx: Context<DateType>
 ) => Promise<void>;

package/src/models/utils.ts

@@ -58,8 +58,12 @@ export const isInputModel = (model: Model): model is InputModel => model instanc
 
 export const isInterfaceModel = (model: Model): model is InterfaceModel => model instanceof InterfaceModel;
 
+export const isCreatableModel = (model: EntityModel) => model.creatable && model.fields.some(isCreatableField);
+
 export const isUpdatableModel = (model: EntityModel) => model.updatable && model.fields.some(isUpdatableField);
 
+export const isCreatableField = (field: EntityField) => !field.inherited && !!field.creatable;
+
 export const isUpdatableField = (field: EntityField) => !field.inherited && !!field.updatable;
 
 export const modelNeedsTable = (model: EntityModel) => model.fields.some((field) => !field.inherited);
@@ -169,3 +173,23 @@ export const retry = async <T>(cb: () => Promise<T>, condition: (e: any) => bool
     }
   }
 };
+
+type Typeof = {
+  string: string;
+  number: number;
+  bigint: bigint;
+  boolean: boolean;
+  symbol: symbol;
+  undefined: undefined;
+  object: object;
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  function: Function;
+};
+
+export const as = <T extends keyof Typeof>(value: unknown, type: T): Typeof[T] => {
+  if (typeof value !== type) {
+    throw new Error(`No string`);
+  }
+
+  return value as Typeof[T];
+};

package/src/permissions/check.ts

@@ -4,7 +4,6 @@ import { NotFoundError, PermissionError } from '../errors';
 import { EntityModel } from '../models/models';
 import { get, isRelation } from '../models/utils';
 import { AliasGenerator, hash, ors } from '../resolvers/utils';
-import { BasicValue } from '../values';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
 export const getRole = (ctx: Pick<FullContext, 'user'>) => ctx.user?.role ?? 'UNAUTHENTICATED';
@@ -89,7 +88,7 @@ export const applyPermissions = (
 export const getEntityToMutate = async (
   ctx: Pick<FullContext, 'models' | 'permissions' | 'user' | 'knex'>,
   model: EntityModel,
-  where: Record<string, BasicValue>,
+  where: Record<string, unknown>,
   action: 'UPDATE' | 'DELETE' | 'RESTORE'
 ) => {
   const query = ctx
@@ -132,7 +131,7 @@ export const getEntityToMutate = async (
 export const checkCanWrite = async (
   ctx: Pick<FullContext, 'models' | 'permissions' | 'user' | 'knex'>,
   model: EntityModel,
-  data: Record<string, BasicValue>,
+  data: Record<string, unknown>,
   action: 'CREATE' | 'UPDATE'
 ) => {
   const permissionStack = getPermissionStack(ctx, model.name, action);

package/src/resolvers/mutations.ts

@@ -1,12 +1,12 @@
 import { GraphQLResolveInfo } from 'graphql';
-import { DateTime } from 'luxon';
 import { v4 as uuid } from 'uuid';
 import { Context, FullContext } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
 import { EntityField, EntityModel } from '../models/models';
-import { Entity, FullEntity } from '../models/mutation-hook';
+import { Entity } from '../models/mutation-hook';
 import { get, isPrimitive, it, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
+import { anyDateToLuxon } from '../utils';
 import { resolve } from './resolver';
 import { AliasGenerator } from './utils';
 
@@ -151,7 +151,7 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const deleteCascade = async (currentModel: EntityModel, entity: FullEntity) => {
+  const deleteCascade = async (currentModel: EntityModel, entity: Entity) => {
     if (entity.deleted) {
       return;
     }
@@ -266,8 +266,12 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const restoreCascade = async (currentModel: EntityModel, relatedEntity: FullEntity) => {
-    if (!relatedEntity.deleted || !relatedEntity.deletedAt || !relatedEntity.deletedAt.equals(entity.deletedAt)) {
+  const restoreCascade = async (currentModel: EntityModel, relatedEntity: Entity) => {
+    if (
+      !relatedEntity.deleted ||
+      !relatedEntity.deletedAt ||
+      anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone).equals(anyDateToLuxon(entity.deletedAt, ctx.timeZone))
+    ) {
       return;
     }
 
@@ -365,7 +369,7 @@ const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
     }
 
     if (isEndOfDay(field) && data[key]) {
-      data[key] = (data[key] as DateTime).endOf('day');
+      data[key] = anyDateToLuxon(data[key], ctx.timeZone);
       continue;
     }