@rvoh/dream 2.0.4 → 2.1.2

package/CHANGELOG.md

@@ -0,0 +1,332 @@
+## 2.1.2
+
+- add missing peerDependencies
+
+## 2.1.1
+
+generators support alternate casings when parsing association statements (i.e. `psy g model Pet user:belongsTo`)
+
+## 2.1.0
+
+- Change type file generation to AST
+- Soft-deprecate DBClass (automatically updated on sync)
+
+## 2.0.4
+
+improve CLI command descriptions
+
+## 2.0.3
+
+don't require database to exist when creating migrations (fixes create-psychic with uuid primary keys)
+
+## 2.0.2
+
+bump glob to close dependabot alerts
+
+## 2.0.1
+
+remove dream-spec-helpers from peer dependencies
+
+## 2.0.0
+
+- namespace package exports
+- remove `Benchmark`
+- Remove `leftJoinPreloadFor` and `leftJoinLoadFor`. They were never a good idea since the idea of `preloadFor` is that one doesn't need to pay attention to all the things that need to be preloaded, but in a join situation, this is a recipe for disaster since loading tables in parallel results in a Cartesian product of result rows being
+
+## 1.13.0
+
+- generated code uses absolute imports
+- `Virtual` decorator requires OpenAPI shape
+- don't let a null value in a `Sortable` column break future sorts (null may enter via a migration or `skipHooks`)
+- simplify and DRY up Sortable
+- Sortable keeps values within the range 1 to N
+- fix STI child generation with array attributes (arrays can always be initialized to an empty array, so can leverage a regular non-null constraint). E.g:
+
+  ```
+  yarn psy g:sti-child Room/Bedroom extends Room bed_types:enum\[\]:bed_types:twin,bunk,queen,king,cot,sofabed
+  ```
+
+## 1.12.0
+
+- DateTime and CalendarDate are always valid and throw an error if invalid
+
+## 1.11.0
+
+- fix `scrollPaginate` when the column being ordered by is not unique
+- fix `pluck` so it properly omits soft-deleted records
+
+## 1.11.0
+
+- `association` and `associationOrFail` handle required and passthrough `and` clauses
+- `association` and `associationOrFail` compatible with transactions
+- `scrollPaginate` Query and static Dream methods
+- remove `paginate` from DreamClassTransactionBuilder
+
+## 1.10.0
+
+- bump kysely
+- paginate includes default ordering on id
+- cli command to ensure migrations have been run prior to running specs
+- fix ability to sync when type files don't reflect models
+- leverage Map instead of an object so don't need to prefix numeric keys with underscore to prevent them from being sorted by numeric value rather than by the order in which they were added to the map
+- renameTable migration helper
+- the key function passed to `sortBy` may now also return a DateTime, a CalendarDate, or a bigint
+- fix `sort` on bigint arrays
+- `percent` function
+- `association` and `associationOrFail` methods to encapsulate the loaded check or associationQuery ternary pattern
+- generated association name and id for a `belongs_to` association are based on the final part of the model name, not the entire namespace [requires Psychic update for generated resource controllers/specs to generate valid code]
+- [BREAKING] `on` replaces `foreignKey` in association declarations, e.g.:
+
+  ```
+    @deco.HasOne('BalloonLine', { on: 'balloonId' })
+    public balloonLine: BalloonLine
+  ```
+
+- generated migrations include index on foreign key
+- don't require openapi for delegatedType when delegating to an association since we can derive the openapi type automatically [requires Psychic update for proper OpenAPI shape to be generated]
+- fix OpenAPI in generated STI base serializer
+
+## 1.9.4
+
+- if `required: false`, leave the property undefined rather than rendering as `null`
+
+## 1.9.3
+
+- serializer builder attribute option types allow `required: false`; this will be used by Psychic to omit attributes from the required array in OpenaAPI
+
+## 1.9.2
+
+- allow null for ops argument to a where clause on a datetime or date column
+
+## 1.9.1
+
+- fix where clause range types to allow mixing of CalendarDate and DateTime between start and end of range
+- DateTime and CalendarDate may be used in ops when comparing against a date or datetime column
+
+## 1.9.0
+
+Fix broken param safe type columns so that:
+
+1. polymorphic type fields are excluded from param safe types
+2. association names are excluded
+
+Bumping minor, since it could introduce breaking changes for those reliant on previous param safe behavior.
+
+## 1.8.0
+
+- throw ColumnOverflow when saving too long a string / number to a database column
+- make all of these errors extend the same error so Psychic can check a single error type when deciding to return 400
+
+## 1.7.3
+
+- remove unnecessary token, now that we are open-sourced
+
+## 1.7.2
+
+- fix issue causing generators to generate invalid uuid primary keys
+
+## 1.7.1
+
+- fix error when file without default export exists in the models directory hierarchy
+
+## 1.7.0
+
+- Remove `Dream#isDreamInstance` and `DreamSerializerBuilder/ObjectSerializerBuilder#isSerializer`
+- Export `MissingSerializersDefinition`
+
+## 1.6.0
+
+- Move sanitization to Psychic so it can sanitize to real unicode representations
+
+## 1.5.2
+
+- Don't require `openapi` for virtual attributes
+- Fix Sortable with null value in scope column
+- Enable sanitization of serialized attributes
+- Enable `<association>.<column>: null` where statements even when the column can't be null so that queries can be constructed to locate models that don't have a particular association
+
+## 1.5.1
+
+Add `DreamMigrationHelpers.newTransaction()` to support explicitly starting a new transaction within a migration.
+
+## 1.5.0
+
+- add support for multiple database connections in a single dream application. To take advantage of this new feature, you can do the following:
+
+1. Add a new connection configuration to your conf/dream.ts file, providing it an explicit alternate connection name as the second argument, like so:
+
+```ts
+dreamApp.set('db', 'myAlternateConnection', {
+  primary: {
+    user: AppEnv.string('DB_USER'),
+    password: AppEnv.string('DB_PASSWORD', { optional: !AppEnv.isProduction }),
+    host: AppEnv.string('DB_HOST', { optional: true }),
+    name: AppEnv.string('ALTERNATE_DB_NAME', { optional: true }),
+    port: AppEnv.integer('ALTERNATE_DB_PORT', { optional: true }),
+    useSsl: false,
+  },
+})
+```
+
+Be sure to add any new environment variables to your .env and .env.test files.
+
+2. Run sync
+
+```sh
+yarn psy sync
+```
+
+3. add a new application model for your new connection, naming it the name of your connection, pascalized, with the string `ApplicationModel` at the end, like so:
+
+```ts
+// app/models/MyAlternateConnectionApplicationModel.ts
+
+import Dream from '../../../src/Dream.js'
+import { DBClass } from '../../types/db.alternateConnection.js'
+import { connectionTypeConfig, schema } from '../../types/dream.alternateConnection.js'
+import { globalTypeConfig } from '../../types/dream.globals.js'
+
+export default class MyAlternateConnectionApplicationModel extends Dream {
+  declare public DB: DBClass
+
+  public override get connectionName() {
+    return 'alternateConnection' as const
+  }
+
+  public override get schema(): any {
+    return schema
+  }
+
+  public override get connectionTypeConfig() {
+    return connectionTypeConfig
+  }
+
+  public override get globalTypeConfig() {
+    return globalTypeConfig
+  }
+}
+```
+
+4. Now you can proceed to generate a model for your new connection, like so:
+
+```sh
+yarn psy g:model MyNewModel someField:text --connection-name=myAlternateConnection
+```
+
+Dream will automatically read the connectionName and use it to derive the `MyAlternateConnectionApplicationModel` automatically, though if this isn't correct, you will need to manually adjust it.
+
+5. Alternate db engine support
+
+If you would like to use an alternate db engine, this is also now supported. To do this, you will need to provide a query driver class that extends one of our base query driver classes. As an example, I recommend you take a look at the `MysqlQueryDriver.ts` file housed within the test-app folder of this repo. This class is not ready for production use, but is a good jumping off point for those interested in supporting a different query driver for dream.
+
+To utilize this feature, simply provide a different query driver class in your db connection config, like so:
+
+```ts
+// conf/dream.ts
+
+  app.set('db', {
+    queryDriverClass: MyCustomQueryDriverClass,
+    ...
+  })
+```
+
+## 1.4.2
+
+- add ability to set custom import extension, which will be used when generating new files for your application
+
+## 1.4.1
+
+- cache Dream app earlier in the initialization sequence
+
+## 1.4.0
+
+- fix `preloadFor` infinite loop when serializers have circular references
+
+- generated STI base serializer updated to only include the single type of the particular STI child in the OpenAPI shape for that child
+
+- change `primaryKeyValue` from a getter to a method so it can return the correct type even when `primaryKey` has been overridden on a particular Dream model
+
+- remove `IdType`, an unnecessary abstraction that caused type inconsistencies
+
+- explicitly handle bigint from the database as string
+
+## 1.3.3
+
+- make `referenceTypeString` public
+
+## 1.3.2
+
+- restore aliasing in preload/load queries
+
+## 1.3.1
+
+- throw NotNullViolation when Postgres throws a not null violation
+
+- throw CheckViolation when Postgres throws a check violation
+
+## 1.3.0
+
+- sti-child generator includes check constraint instead of not-null since the column should only be not-null for that STI child (or modified by hand to accommodate more than one STI child)
+
+- add `Dream#hasAssociation`
+
+- fix preloading associations on other side of a polyorphic belongs-to association so that we don't set an association on a dream model that doesn't define that association
+
+- fix preloading association on the other side of a polymorphic belongs-to since the same association name may be defined differently on different models. For example, taskable may be a Chore or a Workout, both of which have an `images` association, but `images` goes through ChoreImage on Chore and through WorkoutImage on Workout
+
+- fix preloadFor when a rendersOne/Many renders a polymorphic belongs-to (was only preloading serializer associations for one of the polymorphically associated models)
+
+- fix preloadFor when an explicit serializer option is provided to a rendersOne/Many
+
+## 1.2.1
+
+- Throw DataTypeColumnTypeMismatch when Postgres throws an error attempting to save to a column with a value that can't be cast to the column type.
+
+## 1.2.0
+
+- Add Dream.lookup, enabling devs to tap into the IOC provided by dream to dodge circular import issues
+
+## 1.1.2
+
+- CliFileWriter does not raise error if the file we are writing is not in the file system yet.
+
+## 1.1.1
+
+- Add fs.writeFile options as third argument to CliFileWriter.write, enabling psychic to provide custom flags when writing openapi.json files.
+
+## 1.1.0
+
+- Remove support for preloadThroughColumns. They were broken, fixing them would be overly complex, and the same effect can be obtained using flatten on a serializer rendersOne
+
+## 1.0.6
+
+- Fix joining after a through a polymorphic BelongsTo
+  association.
+
+- Improve join implementation
+
+- Disable leftJoinPreload preloadThroughColumns since it doesn't actually work on through associations that resolve to a source that doesn't match the association name (and we were unnecessarily including columns in the leftJoinPreload statement even when there was no `preloadThroughColumns`, thereby bloating the queries unnecessarily)
+
+## 1.0.5
+
+- Support HasOne/Many through polymorphic BelongsTo (trick is that it uses the associated model from the HasOne/Many to limit the BelongsTo to a single associated class / table)
+
+- Fix HasOne/Many through source type
+
+- sync process is now fail-safe, leveraging a utility which caches old copies of files before writing to them. If an exception is thrown at any point during the process, dream will revert all files written using the new `CliFileWriter` class
+
+## 1.0.4
+
+- properly exclude type from `DreamParamSafeColumnNames`
+
+## 1.0.3
+
+- exclude type from `DreamParamSafeColumnNames`
+
+## 1.0.2
+
+- stop computing foreign keys in schema builder when building schema for through associations
+
+## 1.0.1
+
+- [bug] fix preloading STI model via polymporhic association (polymorphic type was being altered to the STI child rather than left as the STI base)

package/dist/cjs/src/bin/index.js

@@ -1,6 +1,7 @@
 import DreamCLI from '../cli/index.js';
 import DreamApp from '../dream-app/index.js';
 import Query from '../dream/Query.js';
+import DBClassDeprecation from '../helpers/cli/DBClassDeprecation.js';
 import generateDream from '../helpers/cli/generateDream.js';
 import sspawn from '../helpers/sspawn.js';
 export default class DreamBin {
@@ -9,6 +10,7 @@ export default class DreamBin {
         for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
             await Query.dbDriverClass(connectionName).sync(connectionName, onSync, options);
         }
+        await new DBClassDeprecation().deprecate();
     }
     static async dbCreate() {
         const dreamApp = DreamApp.getOrFail();

package/dist/cjs/src/db/helpers/dreamSchemaTypesFilenameForConnection.js

@@ -0,0 +1,3 @@
+export default function dreamSchemaTypesFilenameForConnection(connectionName) {
+    return connectionName === 'default' ? 'dream.ts' : `dream.${connectionName}.ts`;
+}

package/dist/cjs/src/db/helpers/syncDbTypesFiles.js

@@ -1,14 +1,10 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
 import colorize from '../../cli/logger/loggable/colorize.js';
 import DreamApp from '../../dream-app/index.js';
-import autogeneratedFileDisclaimer from '../../helpers/cli/autoGeneratedFileDisclaimer.js';
-import compact from '../../helpers/compact.js';
-import EnvInternal from '../../helpers/EnvInternal.js';
+import ASTKyselyCodegenEnhancer from '../../helpers/cli/ASTKyselyCodegenEnhancer.js';
 import dreamPath from '../../helpers/path/dreamPath.js';
-import snakeify from '../../helpers/snakeify.js';
 import sspawn from '../../helpers/sspawn.js';
 import dbTypesFilenameForConnection from './dbTypesFilenameForConnection.js';
 export default async function syncDbTypesFiles(connectionName) {
@@ -26,88 +22,5 @@ export default async function syncDbTypesFiles(connectionName) {
             });
         },
     });
-    // intentionally bypassing helpers here, since they often end up referencing
-    // from the dist folder, whereas dirname here is pointing to true src folder.
-    const file = (await fs.readFile(absoluteDbSyncPath)).toString();
-    const enhancedSchema = enhanceSchema(file);
-    await CliFileWriter.write(absoluteDbSyncPath, enhancedSchema);
-}
-// begin: schema helpers
-function enhanceSchema(file) {
-    file = removeUnwantedExports(file);
-    file = replaceInt8Type(file);
-    file = replaceJsonType(file);
-    const interfaces = file.split(/export interface /g);
-    const results = interfaces.slice(1, interfaces.length);
-    const dbInterface = results.find(str => /^DB \{/.test(str));
-    const camelDbInterface = camelcasify(dbInterface);
-    file = camelcasify(file);
-    file = file.replace(camelDbInterface, dbInterface);
-    file = addCustomImports(file);
-    const transformedNames = compact(results.map(result => transformName(result)));
-    const fileWithCoercedTypes = exportedEnumTypesToExportedTypeValues(file);
-    // BEGIN FILE CONTENTS BUILDING
-    const newFileContents = `${fileWithCoercedTypes}
-
-export class DBClass {
-  ${transformedNames
-        .map(name => `${snakeify(name)}: ${name}`)
-        .sort()
-        .join('\n  ')}
-}
-`;
-    const sortedFileContents = alphaSortInterfaceProperties(newFileContents);
-    return sortedFileContents;
-}
-function removeUnwantedExports(file) {
-    return file.replace(/\nexport type Timestamp = ColumnType<.*/, `export type Timestamp = ColumnType<DateTime | CalendarDate>`);
-}
-function addCustomImports(file) {
-    const customImports = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT')
-        ? "import type CalendarDate from '../../src/helpers/CalendarDate.js'\nimport { type DateTime } from '../../src/helpers/DateTime.js'"
-        : "import { type CalendarDate, type DateTime } from '@rvoh/dream'";
-    return `${autogeneratedFileDisclaimer()}${customImports}
-${file}`;
-}
-function replaceInt8Type(str) {
-    return str.replace('export type Int8 = ColumnType<string, bigint | number | string>', 'export type Int8 = ColumnType<string, bigint | number | string, bigint | number | string>');
-}
-function replaceJsonType(str) {
-    return str.replace('export type Json = ColumnType<JsonValue, string, string>', 'export type Json = ColumnType<JsonValue, string | JsonValue, string | JsonValue>');
-}
-function camelcasify(str) {
-    return _camelcasify(str);
-}
-function _camelcasify(str) {
-    const camelString = str.replace(/([( .])([a-z][a-zA-Z0-9]*)_([a-z0-9])([a-z0-9]*)/g, (match, p1, p2, p3, p4) => `${p1}${p2}${p3.toUpperCase()}${p4}`);
-    return camelString === str ? camelString : _camelcasify(camelString);
-}
-function alphaSortInterfaceProperties(str) {
-    return str.replace(/(export interface [^\n{]+){\n([^}]+)\n}/g, (_match, interfaceDeclaration, lines) => {
-        const props = lines.split(/\n/);
-        return `${interfaceDeclaration}{
-${props.sort().join('\n')}
-}`;
-    });
-}
-function exportedEnumTypesToExportedTypeValues(str) {
-    const ommitedTypes = ['Generated<T>', 'Json', 'JsonArray', 'JsonObject', 'JsonPrimitive', 'JsonValue'];
-    return str.replace(/export type ([^=]*) = ((?!ColumnType)[^;\n]*);/g, (_match, typeDeclaration, types) => {
-        const originalType = `export type ${typeDeclaration} = ${types};`;
-        if (ommitedTypes.some(type => type === typeDeclaration)) {
-            return originalType;
-        }
-        return `\
-${originalType}
-export const ${typeDeclaration}Values = [
-  ${types.split(' | ').join(',\n  ')}
-] as const
-`;
-    });
-}
-function transformName(str) {
-    const name = str.split(' {')[0]?.replace(/\s/g, '');
-    if (name === undefined || name === 'DB')
-        return null;
-    return name;
+    await new ASTKyselyCodegenEnhancer(connectionName).enhance();
 }

package/dist/cjs/src/dream/QueryDriver/Base.js

@@ -90,7 +90,7 @@ export default class QueryDriverBase {
      *    this file is extremely complex and messy, and will be difficult
      *    to achieve.
      * 2. generate a types/dream.ts file in the same shape as the existing
-     *    one. This is normally done using `await new SchemaBuilder().build()`,
+     *    one. This is normally done using the ASTSchemaBuilder
      *    but this will likely need to be overridden to tailor to your custom
      *    database engine.
      */
@@ -172,7 +172,7 @@ export default class QueryDriverBase {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     tableName, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    associationData) {
+    allTableAssociationData) {
         throw new Error('implement getColumnData in child class');
     }
     static serializeDbType(type, val) {

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -34,8 +34,9 @@ import NotNullViolation from '../../errors/db/NotNullViolation.js';
 import UnexpectedUndefined from '../../errors/UnexpectedUndefined.js';
 import CalendarDate from '../../helpers/CalendarDate.js';
 import camelize from '../../helpers/camelize.js';
+import ASTGlobalSchemaBuilder from '../../helpers/cli/ASTGlobalSchemaBuilder.js';
+import ASTSchemaBuilder from '../../helpers/cli/ASTSchemaBuilder.js';
 import generateMigration from '../../helpers/cli/generateMigration.js';
-import SchemaBuilder from '../../helpers/cli/SchemaBuilder.js';
 import compact from '../../helpers/compact.js';
 import { DateTime } from '../../helpers/DateTime.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
@@ -158,31 +159,20 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     /**
      * defines the syncing behavior for dream and psychic,
      * which is run whenever the `sync` command is called.
-     * This is an important step, and will be incredibly
-     * comlpex to override. You will need to do the following
-     * when overriding this method:
-     *
-     * 1. introspect the db and use it to generate a db.ts file in the
-     *    same shape as the existing one. Currently, the process for generating
-     *    this file is extremely complex and messy, and will be difficult
-     *    to achieve.
-     * 2. generate a types/dream.ts file in the same shape as the existing
-     *    one. This is normally done using `await new SchemaBuilder().build()`,
-     *    but this will likely need to be overridden to tailor to your custom
-     *    database engine.
-     */
+     * */
     static async sync(connectionName, onSync, options = {}) {
         try {
             if (!options?.schemaOnly) {
                 await DreamCLI.logger.logProgress(`introspecting db for connection: ${connectionName}...`, async () => {
+                    // this calls kysely-codegen under the hood
                     await syncDbTypesFiles(connectionName);
                 });
             }
-            const schemaBuilder = new SchemaBuilder(connectionName);
+            const newSchemaBuilder = new ASTSchemaBuilder(connectionName);
             await DreamCLI.logger.logProgress(`building dream schema for connection ${connectionName}...`, async () => {
-                await schemaBuilder.build();
+                await newSchemaBuilder.build();
             });
-            if (schemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
+            if (newSchemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
                 await DreamCLI.logger.logProgress('triggering resync to correct for foreign key errors...', async () => {
                     // TODO: make this customizable to enable dream apps to separate
                     const cliCmd = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT') ? 'dream' : 'psy';
@@ -196,7 +186,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     });
                 });
             }
-            await SchemaBuilder.buildGlobalTypes();
+            await new ASTGlobalSchemaBuilder().build();
             if (!options?.schemaOnly) {
                 // intentionally leaving logs off here, since it allows other
                 // onSync handlers to determine their own independent logging approach
@@ -205,7 +195,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         }
         catch (error) {
             console.error(error);
-            await DreamCLI.logger.logProgress('sync failed, reverting file contents...', async () => {
+            await DreamCLI.logger.logProgress('[dream] sync failed, reverting file contents...', async () => {
                 await CliFileWriter.revert();
             });
         }

package/dist/cjs/src/dream/QueryDriver/Postgres.js

@@ -111,7 +111,7 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
      * this is used by the SchemaBuilder to store column data permanently
      * within the types/dream.ts file.
      */
-    static async getColumnData(connectionName, tableName, associationData) {
+    static async getColumnData(connectionName, tableName, allTableAssociationData) {
         const db = this.dbFor(connectionName, 'primary');
         const sqlQuery = sql `SELECT column_name, udt_name::regtype, is_nullable, data_type FROM information_schema.columns WHERE table_name = ${tableName}`;
         const columnToDBTypeMap = await sqlQuery.execute(db);
@@ -120,7 +120,7 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
         rows.forEach(row => {
             const isEnum = ['USER-DEFINED', 'ARRAY'].includes(row.dataType) && !isPrimitiveDataType(row.udtName);
             const isArray = ['ARRAY'].includes(row.dataType);
-            const associationMetadata = associationData[row.columnName];
+            const associationMetadata = allTableAssociationData[row.columnName];
             columnData[camelize(row.columnName)] = {
                 dbType: row.udtName,
                 allowNull: row.isNullable === 'YES',

package/dist/cjs/src/dream-app/index.js

@@ -6,6 +6,7 @@ import Encrypt from '../encrypt/index.js';
 import DreamAppInitMissingCallToLoadModels from '../errors/dream-app/DreamAppInitMissingCallToLoadModels.js';
 import DreamAppInitMissingMissingProjectRoot from '../errors/dream-app/DreamAppInitMissingMissingProjectRoot.js';
 import CalendarDate from '../helpers/CalendarDate.js';
+import autogeneratedFileDisclaimer from '../helpers/cli/autoGeneratedFileDisclaimer.js';
 import { DateTime, Settings } from '../helpers/DateTime.js';
 import EnvInternal from '../helpers/EnvInternal.js';
 import globalClassNameFromFullyQualifiedModelName from '../helpers/globalClassNameFromFullyQualifiedModelName.js';
@@ -92,6 +93,7 @@ export default class DreamApp {
             inferSerializersFromDreamClassOrViewModelClass,
             isDreamSerializer,
             serializerNameFromFullyQualifiedModelName,
+            autogeneratedFileDisclaimer,
         };
     }
     /**
@@ -233,6 +235,16 @@ Try setting it to something valid, like:
     get importExtension() {
         return this._importExtension;
     }
+    /**
+     * if set to true, it will bypass deprecation checks that run
+     * during the sync hook. Defaults to false, we only recommend
+     * overriding this if you are having issues with the deprecation
+     * check.
+     */
+    _bypassDeprecationChecks = false;
+    get bypassDeprecationChecks() {
+        return this._bypassDeprecationChecks;
+    }
     loadedModels = false;
     constructor(opts) {
         if (opts?.db)
@@ -317,6 +329,9 @@ Try setting it to something valid, like:
     }
     set(applyOption, options, secondaryOptions) {
         switch (applyOption) {
+            case 'bypassDeprecationChecks':
+                this._bypassDeprecationChecks = options;
+                break;
             case 'db':
                 if (typeof options === 'string') {
                     this._dbCredentials[options] = secondaryOptions;