drizzle-kit 0.9.38 → 0.9.41

package/src/tests/columnsMachine.test.ts

@@ -0,0 +1,338 @@
+import createResolveColumnsMachine from '../cli/machines/resolveColumnsMachine';
+import { interpret } from 'xstate';
+import { log } from "console";
+
+
+test('Dry run, empty data', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({ name: 'Test', deleted: [], added: [] });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [],
+        renamed: [],
+        deleted: [],
+      });
+
+      service.stop();
+    }
+  });
+});
+
+test('Dry run, empty missing', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({ name: 'Test', deleted: [], added: [{ name: 'new1' }, { name: 'new2' }] });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [{ name: 'new1' }, { name: 'new2' }],
+        renamed: [],
+        deleted: [],
+      });
+
+      service.stop();
+    }
+  });
+});
+
+test('Dry run, empty new', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({ name: 'Test', deleted: [{ name: 'missing1' }, { name: 'missing2' }], added: [] });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [],
+        renamed: [],
+        deleted: [{ name: 'missing1' }, { name: 'missing2' }],
+      });
+
+      service.stop();
+    }
+  });
+});
+
+test('Delete 2 columns and resolve remaining new columns', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({
+    name: 'Test',
+    deleted: [
+      { name: 'missing1' },
+      { name: 'missing2' }
+    ],
+    added: [{ name: 'new1' }, { name: 'new2' }]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [{ name: 'new1' }, { name: 'new2' }],
+        renamed: [],
+        deleted: [{ name: 'missing1' }, { name: 'missing2' }],
+      });
+
+      service.stop();
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Rename 1 column', (done) => {
+  const machine = createResolveColumnsMachine({
+    name: 'Table',
+    deleted: [
+      { name: 'from' },
+    ],
+    added: [
+      { name: 'to' },
+    ]
+  });
+
+  const service = interpret(machine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+    
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'from' }, to: { name: 'to' } },
+        ],
+        deleted: []
+      });
+
+      service.stop();
+      done()
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Rename 2 columns and resolve remaining missing columns', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({
+    name: 'Test',
+    deleted: [
+      { name: 'missing1' },
+      { name: 'missing2' },
+      { name: 'missing3' },
+    ],
+    added: [
+      { name: 'new1' },
+      { name: 'new2' }
+    ]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'missing1' }, to: { name: 'new1' } },
+          { from: { name: 'missing2' }, to: { name: 'new2' } }
+        ],
+        deleted: [{ name: 'missing3' }]
+      });
+
+      service.stop();
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Rename 2 columns and delete 2 columns', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({
+    name: 'Test',
+    deleted: [
+      { name: 'missing1' },
+      { name: 'missing2' },
+      { name: 'missing3' },
+      { name: 'missing4' },
+    ],
+    added: [
+      { name: 'new1' },
+      { name: 'new2' },
+    ]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'missing1' }, to: { name: 'new1' } },
+          { from: { name: 'missing3' }, to: { name: 'new2' } }
+        ],
+        deleted: [{ name: 'missing2' }, { name: 'missing4' }]
+      });
+
+      service.stop();
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Delete 2 columns, rename 2 columns and resolve remaining missing', () => {
+  const resolveTablesMachine = createResolveColumnsMachine({
+    name: 'Test',
+    deleted: [
+      { name: 'missing1' },
+      { name: 'missing2' },
+      { name: 'missing3' },
+      { name: 'missing4' },
+      { name: 'missing5' },
+      { name: 'missing6' },
+    ],
+    added: [
+      { name: 'new1' },
+      { name: 'new2' },
+    ]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      created,
+      renamed,
+      deleted,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created,
+        renamed,
+        deleted,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'missing2' }, to: { name: 'new1' } },
+          { from: { name: 'missing4' }, to: { name: 'new2' } }
+        ],
+        deleted: [{ name: 'missing1' }, { name: 'missing3' }, { name: 'missing5' }, { name: 'missing6' }]
+      });
+
+      service.stop();
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+});
+
+export { };

package/src/tests/tablesMachine.test.ts

@@ -0,0 +1,339 @@
+import createResolveTablesMachine from '../cli/machines/resolveTablesMachine';
+import { log } from "console";
+
+import { interpret } from 'xstate';
+
+test('Dry run, empty data', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({ missingTables: [], newTables: [] });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [],
+        renamed: [],
+        deleted: [],
+      });
+
+      service.stop();
+      done()
+    }
+  });
+});
+
+test('Dry run, empty missing', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({ missingTables: [], newTables: [{ name: 'new1' }, { name: 'new2' }] });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [{ name: 'new1' }, { name: 'new2' }],
+        renamed: [],
+        deleted: [],
+      });
+
+      service.stop();
+      done()
+    }
+  });
+});
+
+test('Rename 1 table', (done) => {
+  const machine = createResolveTablesMachine({
+    missingTables: [
+      { name: 'from' },
+    ],
+    newTables: [
+      { name: 'to' },
+    ]
+  });
+
+  const service = interpret(machine).start();
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'from' }, to: { name: 'to' } },
+        ],
+        deleted: []
+      });
+
+      service.stop();
+      done()
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Dry run, empty new', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({ missingTables: [{ name: 'missing1' }, { name: 'missing2' }], newTables: [] });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [],
+        renamed: [],
+        deleted: [{ name: 'missing1' }, { name: 'missing2' }],
+      });
+
+      service.stop();
+      done()
+    }
+  });
+});
+
+test('Delete 2 tables and resolve remaining new tables', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({
+    missingTables: [
+      { name: 'missing1' },
+      { name: 'missing2' }
+    ],
+    newTables: [{ name: 'new1' }, { name: 'new2' }]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [{ name: 'new1' }, { name: 'new2' }],
+        renamed: [],
+        deleted: [{ name: 'missing1' }, { name: 'missing2' }],
+      });
+
+      service.stop();
+      done()
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Rename 2 tables and resolve remaining missing tables', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({
+    missingTables: [
+      { name: 'missing1' },
+      { name: 'missing2' },
+      { name: 'missing3' },
+    ],
+    newTables: [
+      { name: 'new1' },
+      { name: 'new2' }
+    ]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'missing1' }, to: { name: 'new1' } },
+          { from: { name: 'missing2' }, to: { name: 'new2' } }
+        ],
+        deleted: [{ name: 'missing3' }]
+      });
+
+      service.stop();
+      done()
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Rename 2 tables and delete 2 tables', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({
+    missingTables: [
+      { name: 'missing1' },
+      { name: 'missing2' },
+      { name: 'missing3' },
+      { name: 'missing4' },
+    ],
+    newTables: [
+      { name: 'new1' },
+      { name: 'new2' }
+    ]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'missing1' }, to: { name: 'new1' } },
+          { from: { name: 'missing3' }, to: { name: 'new2' } }
+        ],
+        deleted: [{ name: 'missing2' }, { name: 'missing4' }]
+      });
+
+      service.stop();
+      done()
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+});
+
+test('Delete 2 tables, rename 2 tables and resolve remaining missing', (done) => {
+  const resolveTablesMachine = createResolveTablesMachine({
+    missingTables: [
+      { name: 'missing1' },
+      { name: 'missing2' },
+      { name: 'missing3' },
+      { name: 'missing4' },
+      { name: 'missing5' },
+      { name: 'missing6' },
+    ],
+    newTables: [
+      { name: 'new1' },
+      { name: 'new2' },
+    ]
+  });
+  const service = interpret(resolveTablesMachine).start();
+
+  service.subscribe((state) => {
+    const {
+      createdTables,
+      renamedTables,
+      deletedTables,
+    } = state.context;
+
+    if (state.changed && state.matches('done')) {
+      expect({
+        created: createdTables,
+        renamed: renamedTables,
+        deleted: deletedTables,
+      }).toStrictEqual({
+        created: [],
+        renamed: [
+          { from: { name: 'missing2' }, to: { name: 'new1' } },
+          { from: { name: 'missing4' }, to: { name: 'new2' } }
+        ],
+        deleted: [{ name: 'missing1' }, { name: 'missing3' }, { name: 'missing5' }, { name: 'missing6' }]
+      });
+
+      service.stop();
+      done()
+    }
+  });
+
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'DELETED' });
+  service.send({ type: 'CONFIRM' });
+  service.send({ type: 'CHOICE_ITEM', itemIndex: 0 });
+  service.send({ type: 'RENAMED' });
+  service.send({ type: 'CHOICE_NEW_ITEM', itemIndex: 0 });
+  service.send({ type: 'CONFIRM' });
+});
+
+export { };

package/tests/alters/index.test.ts

@@ -0,0 +1,22 @@
+import { prepareTestSQL } from "../../dev/testrunner";
+import { DbConnector } from "drizzle-orm";
+import path from "path";
+import "pretty-error/start";
+import { test } from "uvu";
+
+test("import dry json", async () => {
+  const { initSQL, migrationSQL } = await prepareTestSQL(
+    path.join(__dirname, "suite1")
+  );
+  const db = await new DbConnector()
+    .connectionString(
+      "postgresql://postgres:lambdapass@127.0.0.1:5432/postgres"
+    )
+    .connect();
+  console.log(initSQL);
+  await db.session().execute(initSQL);
+  console.log(migrationSQL);
+  await db.session().execute(migrationSQL);
+});
+
+test.run();

package/tests/alters/suite1/_patch.yaml

@@ -0,0 +1,16 @@
+## auth_otp renamed to auth_otp1
+tables:
+  removed:
+    - auth_otp
+  added:
+    - auth_otp1
+  sequence:
+    - 0-0
+columns_in_tables:
+  auth_otp1:
+    removed:
+      - phone1
+    added:
+      - phone
+    sequence:
+      - 0-0