drizzle-orm 0.10.45 → 0.10.46

package/tests/columnTypesTests/int/int.test.js

@@ -0,0 +1,561 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+require("dotenv/config");
+const uvu_1 = require("uvu");
+const assert = __importStar(require("uvu/assert"));
+const src_1 = require("../../../src");
+const utils_1 = require("../../utils");
+const models_1 = require("./models");
+const allIntsTable_1 = __importStar(require("./to/allIntsTable")), schema = allIntsTable_1;
+const allIntsTable_2 = require("./to/allIntsTable");
+const AllIntsSuite = uvu_1.suite('AllIntsSuite', {
+    db: undefined,
+    allIntsTable: undefined,
+});
+AllIntsSuite.before(async (context) => {
+    try {
+        const db = await new src_1.DbConnector()
+            .params({
+            database: process.env.POSTGRES_DB,
+            host: process.env.POSTGRES_HOST,
+            port: Number(process.env.POSTGRES_PORT),
+            password: process.env.POSTGRES_PASSWORD,
+            user: 'postgres',
+        })
+            .connect();
+        context.db = db;
+        context.allIntsTable = new allIntsTable_1.default(db);
+        const sql = await utils_1.prepareTestSqlFromSchema(schema);
+        await db.session().execute(sql);
+    }
+    catch (e) {
+        console.log(e);
+    }
+});
+// Success cases
+// Flow
+// 1. insert by <strategy>
+//  -> 2.select and check expected values (full + several partial selects)
+//      -> 3. update by <strategy>
+//          -> 4. select and check expected values (full + several partial selects)
+//              -> 5. delete by <strategy>
+//                  -> 6. select and check expected values (full + several partial selects)
+// Insert strategies (each insert should have all() + execute()
+//      After using all() -> check that returned object fields are expected
+// )
+// 1. insert all fields to table;
+// 2. insert all required fields to table;
+// 3. insertMany with same model for all inserted values;
+// 4. insertMany with different models for all inserted values;
+// 5. insert with onConflict statement on each field, that has such possibility(upsert)
+// Update strategies (each update should have all() + execute()
+//      After using all() -> check that returned object fields are expected
+// )
+// 1. Update all fields from table;
+// 2. Update 1 by 1 field from table;
+// 3. Update batches of several fields from table(2-3 different batches will be enough);
+// Delete strategies (each delete should have all() + execute()
+//      After using all() -> check that returned object fields are expected
+// )
+// 1. Delete rows by each field values
+// Exception cases
+// Insert cases
+// 1. Insert with same unique key - should have an excpetion
+// 2. Insert with same primary key - should have an excpetion
+// 3. Insert float instead of int - should have an excpetion
+// 4. OnConflict was used by unexisting index - should have an exception
+// Update cases
+// 1. Update with same unique key - should have an excpetion
+// 2. Update with same primary key - should have an excpetion
+// 3. Update to float instead of int - should have an excpetion
+// Delete cases
+// Select cases
+// Insert
+AllIntsSuite('Insert all fields to table', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    const insertedValues = await allIntsTable.insert(models_1.mixedFields).all();
+    const fullSelectResponse = await allIntsTable.select().all();
+    const partialSelectResponse = await allIntsTable
+        .select({
+        notNullInt: allIntsTable.notNullInt,
+        intWithDefault: allIntsTable.intWithDefault,
+    })
+        .all();
+    assert.is(insertedValues.length, 1);
+    assert.equal(insertedValues[0], models_1.mixedFields);
+    assert.is(fullSelectResponse.length, 2);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0], models_1.allPositiveFields);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0], models_1.mixedFields);
+    assert.is(partialSelectResponse.length, 2);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.allPositiveFields.notNullInt)[0]
+        .intWithDefault, models_1.allPositiveFields.intWithDefault);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.mixedFields.notNullInt)[0]
+        .intWithDefault, models_1.mixedFields.intWithDefault);
+});
+AllIntsSuite('Insert all required fields to table', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.requiredPositiveFields).execute();
+    const insertedValues = await allIntsTable.insert(models_1.requiredMixedFields).all();
+    const fullSelectResponse = await allIntsTable.select().all();
+    const partialSelectResponse = await allIntsTable
+        .select({
+        notNullInt: allIntsTable.notNullInt,
+        notNullIntWithDefault: allIntsTable.notNullIntWithDefault,
+        notNullUniqueInt: allIntsTable.notNullUniqueInt,
+    })
+        .all();
+    assert.is(insertedValues.length, 1);
+    assert.equal(insertedValues[0], {
+        ...models_1.requiredMixedFields,
+        serialInt: 2,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.is(fullSelectResponse.length, 2);
+    assert.equal(fullSelectResponse.filter((it) => it.primaryInt === models_1.requiredPositiveFields.primaryInt)[0], {
+        ...models_1.requiredPositiveFields,
+        serialInt: 1,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.equal(fullSelectResponse.filter((it) => it.primaryInt === models_1.requiredMixedFields.primaryInt)[0], {
+        ...models_1.requiredMixedFields,
+        serialInt: 2,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.is(partialSelectResponse.length, 2);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.requiredPositiveFields.notNullInt)[0]
+        .notNullInt, models_1.requiredPositiveFields.notNullInt);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.requiredMixedFields.notNullInt)[0]
+        .notNullInt, models_1.requiredMixedFields.notNullInt);
+});
+AllIntsSuite('InsertMany with same model for all inserted values', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insertMany([models_1.allPositiveFields, models_1.mixedFields]).execute();
+    const insertedValues = await allIntsTable
+        .insertMany([models_1.updatePositiveFields, models_1.updateMixedFields])
+        .all();
+    const fullSelectResponse = await allIntsTable.select().all();
+    const partialSelectResponse = await allIntsTable
+        .select({
+        notNullInt: allIntsTable.notNullInt,
+        notNullIntWithDefault: allIntsTable.notNullIntWithDefault,
+        notNullUniqueInt: allIntsTable.notNullUniqueInt,
+    })
+        .all();
+    assert.is(insertedValues.length, 2);
+    assert.equal(insertedValues[0], models_1.updatePositiveFields);
+    assert.equal(insertedValues[1], models_1.updateMixedFields);
+    assert.is(fullSelectResponse.length, 4);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0], models_1.allPositiveFields);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0], models_1.mixedFields);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.updatePositiveFields.serialInt)[0], models_1.updatePositiveFields);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.updateMixedFields.serialInt)[0], models_1.updateMixedFields);
+    assert.is(partialSelectResponse.length, 4);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.allPositiveFields.notNullInt)[0]
+        .notNullUniqueInt, models_1.allPositiveFields.notNullUniqueInt);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.mixedFields.notNullInt)[0]
+        .notNullUniqueInt, models_1.mixedFields.notNullUniqueInt);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.updatePositiveFields.notNullInt)[0]
+        .notNullUniqueInt, models_1.updatePositiveFields.notNullUniqueInt);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.updateMixedFields.notNullInt)[0]
+        .notNullUniqueInt, models_1.updateMixedFields.notNullUniqueInt);
+});
+AllIntsSuite('InsertMany with different models for all inserted values', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insertMany([models_1.allPositiveFields, models_1.differentPositiveFields]).execute();
+    const insertedValues = await allIntsTable.insertMany([models_1.mixedFields, models_1.differentMixedFields]).all();
+    const fullSelectResponse = await allIntsTable.select().all();
+    const partialSelectResponse = await allIntsTable
+        .select({
+        notNullInt: allIntsTable.notNullInt,
+        notNullIntWithDefault: allIntsTable.notNullIntWithDefault,
+        notNullUniqueInt: allIntsTable.notNullUniqueInt,
+    })
+        .all();
+    assert.is(insertedValues.length, 2);
+    assert.equal(insertedValues[0], models_1.mixedFields);
+    assert.equal(insertedValues[1], {
+        ...models_1.differentMixedFields,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.is(fullSelectResponse.length, 4);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0], models_1.allPositiveFields);
+    assert.equal(fullSelectResponse.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0], models_1.mixedFields);
+    assert.equal(fullSelectResponse.filter((it) => it.primaryInt === models_1.differentPositiveFields.primaryInt)[0], {
+        ...models_1.differentPositiveFields,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.equal(fullSelectResponse.filter((it) => it.primaryInt === models_1.differentMixedFields.primaryInt)[0], {
+        ...models_1.differentMixedFields,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.is(partialSelectResponse.length, 4);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.allPositiveFields.notNullInt)[0]
+        .notNullUniqueInt, models_1.allPositiveFields.notNullUniqueInt);
+    assert.is(partialSelectResponse.filter((it) => it.notNullInt === models_1.mixedFields.notNullInt)[0]
+        .notNullUniqueInt, models_1.mixedFields.notNullUniqueInt);
+    assert.equal(fullSelectResponse.filter((it) => it.primaryInt === models_1.differentPositiveFields.primaryInt)[0], {
+        ...models_1.differentPositiveFields,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+    assert.equal(fullSelectResponse.filter((it) => it.primaryInt === models_1.differentMixedFields.primaryInt)[0], {
+        ...models_1.differentMixedFields,
+        intWithDefault: allIntsTable_2.defaultInt,
+        uniqueInt: undefined,
+        simpleInt: undefined,
+    });
+});
+AllIntsSuite('Insert with onConflict statement', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    try {
+        await allIntsTable
+            .insertMany([models_1.allPositiveFields, models_1.updatePositiveFields])
+            .onConflict((table) => table.simpleIntIndex, { simpleInt: 777 })
+            .all();
+    }
+    catch (err) {
+        assert.unreachable(err.message);
+    }
+    const select = await allIntsTable.select().all();
+    assert.is(select.length, 2);
+    assert.is(select.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0].simpleInt, 777);
+});
+// ticket DRI-17
+// AllIntsSuite('Inserting an null value into a serial field', async (context) => {
+//   const allIntsTable = context.allIntsTable!;
+//   const undefinedSerial = { ...allPositiveFields, serialInt: undefined };
+//   try {
+//     await allIntsTable.insert(undefinedSerial).execute();
+//   } catch (error) {
+//     assert.unreachable(err.message);
+//   }
+//   const selectResponse = await allIntsTable.select().all();
+//   assert.is(selectResponse.length, 1);
+// });
+// Update
+AllIntsSuite('Update all fields from table', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    await allIntsTable.insert(models_1.mixedFields).execute();
+    await allIntsTable
+        .update()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+        .set(models_1.updatePositiveFields)
+        .execute();
+    const updatedValues = await allIntsTable
+        .update()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.mixedFields.serialInt))
+        .set(models_1.updateMixedFields)
+        .all();
+    const fullSelectUpdate = await allIntsTable.select().all();
+    const partialSelectUpdate = await allIntsTable
+        .select({
+        uniqueInt: allIntsTable.uniqueInt,
+        notNullUniqueInt: allIntsTable.notNullUniqueInt,
+    })
+        .all();
+    assert.is(updatedValues.length, 1);
+    assert.equal(updatedValues[0], models_1.updateMixedFields);
+    assert.is(fullSelectUpdate.length, 2);
+    assert.equal(fullSelectUpdate.filter((it) => it.serialInt === models_1.updatePositiveFields.serialInt)[0], models_1.updatePositiveFields);
+    assert.equal(fullSelectUpdate.filter((it) => it.serialInt === models_1.updateMixedFields.serialInt)[0], models_1.updateMixedFields);
+    assert.is(partialSelectUpdate.length, 2);
+    assert.is(partialSelectUpdate.filter((it) => it.uniqueInt === models_1.updatePositiveFields.uniqueInt)[0]
+        .notNullUniqueInt, models_1.updatePositiveFields.notNullUniqueInt);
+    assert.is(partialSelectUpdate.filter((it) => it.uniqueInt === models_1.updateMixedFields.uniqueInt)[0]
+        .notNullUniqueInt, models_1.updateMixedFields.notNullUniqueInt);
+});
+AllIntsSuite('Update 1 by 1 field from table', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    await allIntsTable.insert(models_1.mixedFields).execute();
+    await allIntsTable
+        .update()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+        .set({ simpleInt: models_1.updatePositiveFields.simpleInt })
+        .execute();
+    const updatedValues = await allIntsTable
+        .update()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.mixedFields.serialInt))
+        .set({ simpleInt: models_1.updateMixedFields.simpleInt })
+        .all();
+    const fullSelectUpdate = await allIntsTable.select().all();
+    const partialSelectUpdate = await allIntsTable
+        .select({
+        uniqueInt: allIntsTable.uniqueInt,
+        notNullUniqueInt: allIntsTable.notNullUniqueInt,
+        simpleInt: allIntsTable.simpleInt,
+    })
+        .all();
+    assert.is(updatedValues.length, 1);
+    assert.equal(updatedValues[0], {
+        ...models_1.mixedFields,
+        simpleInt: models_1.updateMixedFields.simpleInt,
+    });
+    assert.is(fullSelectUpdate.length, 2);
+    assert.equal(fullSelectUpdate.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0], {
+        ...models_1.allPositiveFields,
+        simpleInt: models_1.updatePositiveFields.simpleInt,
+    });
+    assert.equal(fullSelectUpdate.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0], {
+        ...models_1.mixedFields,
+        simpleInt: models_1.updateMixedFields.simpleInt,
+    });
+    assert.is(partialSelectUpdate.length, 2);
+    assert.is(partialSelectUpdate.filter((it) => it.uniqueInt === models_1.allPositiveFields.uniqueInt)[0].simpleInt, models_1.updatePositiveFields.simpleInt);
+    assert.is(partialSelectUpdate.filter((it) => it.uniqueInt === models_1.mixedFields.uniqueInt)[0].simpleInt, models_1.updateMixedFields.simpleInt);
+});
+AllIntsSuite('Update batches of several fields from table', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    await allIntsTable.insert(models_1.mixedFields).execute();
+    await allIntsTable
+        .update()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+        .set({
+        notNullUniqueInt: models_1.updatePositiveFields.notNullUniqueInt,
+        notNullInt: models_1.updatePositiveFields.notNullInt,
+        notNullIntWithDefault: models_1.updatePositiveFields.notNullIntWithDefault,
+    })
+        .execute();
+    const updatedValues = await allIntsTable
+        .update()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.mixedFields.serialInt))
+        .set({
+        notNullUniqueInt: models_1.updateMixedFields.notNullUniqueInt,
+        notNullInt: models_1.updateMixedFields.notNullInt,
+        notNullIntWithDefault: models_1.updateMixedFields.notNullIntWithDefault,
+    })
+        .all();
+    const fullSelectUpdate = await allIntsTable.select().all();
+    const partialSelectUpdate = await allIntsTable
+        .select({
+        serialInt: allIntsTable.serialInt,
+        uniqueInt: allIntsTable.uniqueInt,
+        notNullUniqueInt: allIntsTable.notNullUniqueInt,
+    })
+        .all();
+    assert.is(updatedValues.length, 1);
+    assert.equal(updatedValues[0], {
+        ...models_1.mixedFields,
+        notNullUniqueInt: models_1.updateMixedFields.notNullUniqueInt,
+        notNullInt: models_1.updateMixedFields.notNullInt,
+        notNullIntWithDefault: models_1.updateMixedFields.notNullIntWithDefault,
+    });
+    assert.is(fullSelectUpdate.length, 2);
+    assert.equal(fullSelectUpdate.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0], {
+        ...models_1.allPositiveFields,
+        notNullUniqueInt: models_1.updatePositiveFields.notNullUniqueInt,
+        notNullInt: models_1.updatePositiveFields.notNullInt,
+        notNullIntWithDefault: models_1.updatePositiveFields.notNullIntWithDefault,
+    });
+    assert.equal(fullSelectUpdate.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0], {
+        ...models_1.mixedFields,
+        notNullUniqueInt: models_1.updateMixedFields.notNullUniqueInt,
+        notNullInt: models_1.updateMixedFields.notNullInt,
+        notNullIntWithDefault: models_1.updateMixedFields.notNullIntWithDefault,
+    });
+    assert.is(partialSelectUpdate.length, 2);
+    assert.is(partialSelectUpdate.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0]
+        .notNullUniqueInt, models_1.updatePositiveFields.notNullUniqueInt);
+    assert.is(partialSelectUpdate.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0].notNullUniqueInt, models_1.updateMixedFields.notNullUniqueInt);
+});
+// Delete
+AllIntsSuite('Delete by serial int', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    await allIntsTable.insert(models_1.mixedFields).execute();
+    await allIntsTable
+        .delete()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+        .execute();
+    const partialSelectDelete = await allIntsTable
+        .select({
+        primaryInt: allIntsTable.primaryInt,
+        simpleInt: allIntsTable.simpleInt,
+    })
+        .all();
+    const deleteValue = await allIntsTable
+        .delete()
+        .where(src_1.eq(allIntsTable.serialInt, models_1.mixedFields.serialInt))
+        .all();
+    const fullSelectDelete = await allIntsTable.select().all();
+    assert.is(deleteValue.length, 1);
+    assert.equal(deleteValue[0], models_1.mixedFields);
+    assert.is(partialSelectDelete.length, 1);
+    assert.is(partialSelectDelete.filter((it) => it.primaryInt === models_1.mixedFields.primaryInt)[0].simpleInt, models_1.mixedFields.simpleInt);
+    assert.not(partialSelectDelete.filter((it) => it.primaryInt === models_1.allPositiveFields.primaryInt)[0]);
+    assert.is(fullSelectDelete.length, 0);
+    assert.not(fullSelectDelete.filter((it) => it.serialInt === models_1.allPositiveFields.serialInt)[0]);
+    assert.not(fullSelectDelete.filter((it) => it.serialInt === models_1.mixedFields.serialInt)[0]);
+});
+// Exception cases
+// Insert
+AllIntsSuite('Exception cases: insert double primary int', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    const doublePrimaryInt = {
+        ...models_1.allPositiveFields,
+        uniqueInt: Math.round(Math.random() * 100),
+        notNullUniqueInt: Math.round(Math.random() * 100),
+    };
+    try {
+        await allIntsTable.insert(doublePrimaryInt).execute();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.is(err.message, 'duplicate key value violates unique constraint "table_with_all_ints_pkey"');
+    }
+});
+AllIntsSuite('Exception cases: insert double unique int', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    const doubleUniqueInt = {
+        ...models_1.allPositiveFields,
+        primaryInt: Math.round(Math.random() * 100),
+        notNullUniqueInt: Math.round(Math.random() * 100),
+    };
+    try {
+        await allIntsTable.insert(doubleUniqueInt).execute();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.is(err.message, 'duplicate key value violates unique constraint "table_with_all_ints_unique_int_index"');
+    }
+});
+AllIntsSuite('Exception cases: insert float ', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    const addFloat = {
+        ...models_1.allPositiveFields,
+        simpleInt: +(Math.random() * 100).toFixed(2),
+    };
+    try {
+        await allIntsTable.insert(addFloat).execute();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.ok(err.message);
+    }
+});
+AllIntsSuite('Exception cases: onConflict insert used a non-existent index', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    try {
+        await allIntsTable
+            .insertMany([models_1.allPositiveFields, models_1.updatePositiveFields])
+            .onConflict((table) => table.intWithDefaultIndex, { intWithDefault: 777 })
+            .all();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.is(err.message, 'there is no unique or exclusion constraint matching the ON CONFLICT specification');
+    }
+});
+// Exception cases
+// Update
+AllIntsSuite('Exception cases: update double primary int', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    await allIntsTable.insert(models_1.mixedFields).execute();
+    const doublePrimaryIntUpdate = {
+        ...models_1.allPositiveFields,
+        primaryInt: models_1.mixedFields.primaryInt,
+    };
+    try {
+        await allIntsTable
+            .update()
+            .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+            .set(doublePrimaryIntUpdate)
+            .execute();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.is(err.message, 'duplicate key value violates unique constraint "table_with_all_ints_pkey"');
+    }
+});
+AllIntsSuite('Exception cases: update double unique int', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    await allIntsTable.insert(models_1.mixedFields).execute();
+    const doubleUniqueIntUpdate = {
+        ...models_1.allPositiveFields,
+        uniqueInt: models_1.mixedFields.uniqueInt,
+    };
+    try {
+        await allIntsTable
+            .update()
+            .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+            .set(doubleUniqueIntUpdate)
+            .execute();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.is(err.message, 'duplicate key value violates unique constraint "table_with_all_ints_unique_int_index"');
+    }
+});
+AllIntsSuite('Exception cases: update to float', async (context) => {
+    const allIntsTable = context.allIntsTable;
+    await allIntsTable.insert(models_1.allPositiveFields).execute();
+    const addFloatUpdate = {
+        ...models_1.allPositiveFields,
+        simpleInt: +(Math.random() * 100).toFixed(2),
+    };
+    try {
+        await allIntsTable
+            .update()
+            .where(src_1.eq(allIntsTable.serialInt, models_1.allPositiveFields.serialInt))
+            .set(addFloatUpdate)
+            .execute();
+        assert.unreachable('should have thrown');
+    }
+    catch (err) {
+        assert.ok(err.message);
+    }
+});
+AllIntsSuite('Insert1 -> Update1 -> Delete1', async (context) => {
+    const allIntsTable = context.allIntsTable;
+});
+// if needed
+AllIntsSuite.after.each(async (context) => {
+    await context.db.session().execute(`TRUNCATE ${context.allIntsTable.tableName()}`);
+});
+AllIntsSuite.after(async (context) => {
+    await context.db.session().execute(`DROP TABLE ${context.allIntsTable.tableName()}`);
+    await context.db.session().closeConnection();
+});
+AllIntsSuite.run();

package/tests/columnTypesTests/int/models.d.ts

@@ -0,0 +1,10 @@
+import { ExtractModel } from '@/tables';
+import AllIntsTable from './to/allIntsTable';
+export declare const allPositiveFields: ExtractModel<AllIntsTable>;
+export declare const mixedFields: ExtractModel<AllIntsTable>;
+export declare const updatePositiveFields: ExtractModel<AllIntsTable>;
+export declare const updateMixedFields: ExtractModel<AllIntsTable>;
+export declare const requiredPositiveFields: ExtractModel<AllIntsTable>;
+export declare const requiredMixedFields: ExtractModel<AllIntsTable>;
+export declare const differentPositiveFields: ExtractModel<AllIntsTable>;
+export declare const differentMixedFields: ExtractModel<AllIntsTable>;

package/tests/columnTypesTests/int/models.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.differentMixedFields = exports.differentPositiveFields = exports.requiredMixedFields = exports.requiredPositiveFields = exports.updateMixedFields = exports.updatePositiveFields = exports.mixedFields = exports.allPositiveFields = void 0;
+exports.allPositiveFields = {
+    serialInt: 2,
+    primaryInt: 3,
+    simpleInt: 4,
+    notNullInt: 5,
+    intWithDefault: 6,
+    notNullIntWithDefault: 7,
+    uniqueInt: 8,
+    notNullUniqueInt: 9,
+};
+exports.mixedFields = {
+    serialInt: 11,
+    primaryInt: 12,
+    simpleInt: 13,
+    notNullInt: 0,
+    intWithDefault: -1,
+    notNullIntWithDefault: -2,
+    uniqueInt: -3,
+    notNullUniqueInt: -4,
+};
+exports.updatePositiveFields = {
+    primaryInt: 9,
+    serialInt: 8,
+    simpleInt: 7,
+    notNullInt: 6,
+    intWithDefault: 5,
+    notNullIntWithDefault: 4,
+    uniqueInt: 3,
+    notNullUniqueInt: 2,
+};
+exports.updateMixedFields = {
+    primaryInt: -5,
+    serialInt: 14,
+    simpleInt: -1,
+    notNullInt: 7,
+    intWithDefault: 2,
+    notNullIntWithDefault: 16,
+    uniqueInt: -7,
+    notNullUniqueInt: -2,
+};
+exports.requiredPositiveFields = {
+    primaryInt: 15,
+    notNullInt: 5,
+    notNullIntWithDefault: 7,
+    notNullUniqueInt: 18,
+};
+exports.requiredMixedFields = {
+    primaryInt: 17,
+    notNullInt: 0,
+    notNullIntWithDefault: -2,
+    notNullUniqueInt: -12,
+};
+exports.differentPositiveFields = {
+    serialInt: 2,
+    primaryInt: 15,
+    notNullInt: 5,
+    notNullIntWithDefault: 7,
+    notNullUniqueInt: 18,
+};
+exports.differentMixedFields = {
+    serialInt: 11,
+    primaryInt: 17,
+    notNullInt: 0,
+    notNullIntWithDefault: -2,
+    notNullUniqueInt: -12,
+};

package/tests/columnTypesTests/int/to/allIntsTable.d.ts

@@ -0,0 +1,16 @@
+import AbstractTable from '../../../../src/tables/abstractTable';
+export declare const defaultInt = 1;
+export declare const notNullWithDefault = 1;
+export default class AllIntsTable extends AbstractTable<AllIntsTable> {
+    primaryInt: import("../../../../src").Column<import("../../../../src").PgInteger, false, false, this>;
+    serialInt: import("../../../../src").Column<import("../../../../src/columns/types/pgSerial").default, true, true, this>;
+    simpleInt: import("../../../../src").Column<import("../../../../src").PgInteger, true, false, this>;
+    notNullInt: import("../../../../src").Column<import("../../../../src").PgInteger, false, false, this>;
+    intWithDefault: import("../../../../src").Column<import("../../../../src").PgInteger, true, false, this>;
+    notNullIntWithDefault: import("../../../../src").Column<import("../../../../src").PgInteger, true, false, this>;
+    uniqueInt: import("../../../../src").Column<import("../../../../src").PgInteger, true, false, this>;
+    notNullUniqueInt: import("../../../../src").Column<import("../../../../src").PgInteger, false, false, this>;
+    simpleIntIndex: import("../../../../src/indexes/tableIndex").default;
+    intWithDefaultIndex: import("../../../../src/indexes/tableIndex").default;
+    tableName(): string;
+}