Create SSCCE

Author: Vince-Smith

dev/create-sequelize-instance.ts

@@ -7,7 +7,7 @@ export function createSequelize6Instance(options?: Sequelize6Options): Sequelize
   return new Sequelize6(wrapOptions(options));
 }
 
-export function createSequelize7Instance(options?: Sequelize7Options): Sequelize7 {
+export function createSequelize7Instance(options?: Sequelize7Options<any>): Sequelize7 {
   // not compatible with node 10
   const { Sequelize: Sequelize7Constructor } = require('@sequelize/core');
   // @ts-expect-error -- wrapOptions expect sequelize 6.

package.json

@@ -6,16 +6,17 @@
   "type": "commonjs",
   "license": "MIT",
   "dependencies": {
+    "@sequelize/core": "alpha",
     "chai": "^4",
     "chai-as-promised": "^7",
     "chai-datetime": "^1",
     "chalk": "^4.1.2",
     "cross-env": "^7",
     "fs-jetpack": "^4",
     "sequelize": "^6",
-    "@sequelize/core": "alpha",
     "sinon": "^13",
-    "sinon-chai": "^3"
+    "sinon-chai": "^3",
+    "yarn": "^1.22.22"
   },
   "scripts": {
     "_test": "ts-node dev/runner.ts",

src/sscce-sequelize-6.ts

@@ -6,8 +6,6 @@ import sinon from 'sinon';
 // if your issue is dialect specific, remove the dialects you don't need to test on.
 export const testingOnDialects = new Set(['mssql', 'sqlite', 'mysql', 'mariadb', 'postgres', 'postgres-native']);
 
-// You can delete this file if you don't want your SSCCE to be tested against Sequelize 6
-
 // Your SSCCE goes inside this function.
 export async function run() {
   // This function should be used instead of `new Sequelize()`.
@@ -18,24 +16,90 @@ export async function run() {
     define: {
       // For less clutter in the SSCCE
       timestamps: false,
+      underscored: true
     },
   });
 
-  class Foo extends Model {}
-
-  Foo.init({
+class Parents extends Model {};
+Parents.init(
+  {
+    id: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
     name: DataTypes.TEXT,
-  }, {
-    sequelize,
-    modelName: 'Foo',
-  });
+  },
+  {sequelize},
+);
+
+class Children extends Model {};
+Children.init(
+    {
+        id: {
+            type: DataTypes.INTEGER,
+            autoIncrement: true,
+            primaryKey: true,
+        },
+        parentId: {
+            type: DataTypes.INTEGER,
+            references: {
+                model: Parents,
+                key: 'id'
+            }
+        }
+    },
+    {sequelize}
+
+)
+
+class GrandChildren extends Model {};
+GrandChildren.init(
+  {
+    id: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+     parentId: {
+        type: DataTypes.INTEGER,
+        references: {
+            model: Children,
+            key: 'id'
+        }
+    }
+  },
+    {sequelize}
+);
+
+Parents.hasMany(Children)
+Children.belongsTo(Parents)
+Children.hasMany(GrandChildren)
+GrandChildren.belongsTo(Children)
 
   // You can use sinon and chai assertions directly in your SSCCE.
   const spy = sinon.spy();
   sequelize.afterBulkSync(() => spy());
   await sequelize.sync({ force: true });
   expect(spy).to.have.been.called;
 
-  console.log(await Foo.create({ name: 'TS foo' }));
-  expect(await Foo.count()).to.equal(1);
+  const created = await Parents.create()
+  const {rows, count} = await Parents.findAndCountAll({
+      include: {
+        model: Children,
+          required: false,
+          include: [{
+              model: GrandChildren,
+              required: true,
+          }]
+      },
+      limit: 1
+  })
+
+  console.log(rows);
+  expect(created).to.not.be.undefined;
+  expect(created).to.not.be.null;
+  expect(count).to.equal(1);
 }
+
+

src/sscce-sequelize-7.ts

@@ -1,4 +1,4 @@
-import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from '@sequelize/core';
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model, DialectOptions } from '@sequelize/core';
 import { Attribute, NotNull } from '@sequelize/core/decorators-legacy';
 import { createSequelize7Instance } from '../dev/create-sequelize-instance';
 import { expect } from 'chai';
@@ -13,31 +13,96 @@ export const testingOnDialects = new Set(['mssql', 'sqlite', 'mysql', 'mariadb',
 export async function run() {
   // This function should be used instead of `new Sequelize()`.
   // It applies the config for your SSCCE to work on CI.
+
   const sequelize = createSequelize7Instance({
     logQueryParameters: true,
     benchmark: true,
     define: {
       // For less clutter in the SSCCE
       timestamps: false,
+      underscored: true
     },
+    dialect: 'sqlite3'
   });
 
-  class Foo extends Model<InferAttributes<Foo>, InferCreationAttributes<Foo>> {
-    declare id: CreationOptional<number>;
+  class Parents extends Model {};
+  Parents.init(
+    {
+      id: {
+          type: DataTypes.INTEGER,
+          autoIncrement: true,
+          primaryKey: true,
+      },
+      name: DataTypes.TEXT,
+    },
+    {sequelize},
+  );
+
+  class Children extends Model {};
+  Children.init(
+      {
+          id: {
+              type: DataTypes.INTEGER,
+              autoIncrement: true,
+              primaryKey: true,
+          },
+          parentId: {
+              type: DataTypes.INTEGER,
+              references: {
+                  model: Parents,
+                  key: 'id'
+              }
+          }
+      },
+      {sequelize}
+
+  )
+
+  class GrandChildren extends Model {};
+  GrandChildren.init(
+    {
+      id: {
+          type: DataTypes.INTEGER,
+          autoIncrement: true,
+          primaryKey: true,
+      },
+       parentId: {
+          type: DataTypes.INTEGER,
+          references: {
+              model: Children,
+              key: 'id'
+          }
+      }
+    },
+      {sequelize}
+  );
 
-    @Attribute(DataTypes.TEXT)
-    @NotNull
-    declare name: string;
-  }
+  Parents.hasMany(Children)
+  Children.belongsTo(Parents)
+  Children.hasMany(GrandChildren)
+  GrandChildren.belongsTo(Children)
 
-  sequelize.addModels([Foo]);
+    // You can use sinon and chai assertions directly in your SSCCE.
+    const spy = sinon.spy();
+    sequelize.afterBulkSync(() => spy());
+    await sequelize.sync({ force: true });
+    expect(spy).to.have.been.called;
 
-  // You can use sinon and chai assertions directly in your SSCCE.
-  const spy = sinon.spy();
-  sequelize.afterBulkSync(() => spy());
-  await sequelize.sync({ force: true });
-  expect(spy).to.have.been.called;
+    const created = await Parents.create()
+    const {rows, count} = await Parents.findAndCountAll({
+        include: {
+          model: Children,
+            required: false,
+            include: [{
+                model: GrandChildren,
+                required: true,
+            }]
+        },
+        limit: 1
+    })
 
-  console.log(await Foo.create({ name: 'TS foo' }));
-  expect(await Foo.count()).to.equal(1);
+    console.log(rows);
+    expect(created).to.not.be.undefined;
+    expect(created).to.not.be.null;
+    expect(count).to.equal(1);
 }