multum / pg-differ Goto Github PK

This error occurs when trying to synchronize tables in the _normalizeCheckRows method

Planned Features

1. Support for multiple Postges objects(table, sequence and more)

// v1.x
{
  table: 'table_name',
  columns: {},
  ...
}

// v2.0
{
  type: 'table', // table, sequence and more
  properties: {
    name: 'table_name',
    columns: {},
    ...
  }
}

2. Indexes and constraints in the scheme are separated

// v1.x
{
  table: 'table_name',
  indexes: [],
  forceIndexes: [ 'foreignKey', 'primaryKey' ],
  columns: [
    {
      name: 'column_name',
      primaryKey: true,
      references: { ... },
      onUpdate,
      ....
    }
  ]
}

// v2.0
{
  type: 'table',
  properties: {
    name: 'table_name',
    cleanable: {
      foreignKeys: true,
      primaryKeys: true,
    },
    indexes: [],
    primaryKeys: [],
    unique: [],
    foreignKeys: [
      {
        columns: [ 'column_name' ]
        references: { ... },
        onUpdate,
        ....,
      },
    ],
    columns: [
      {
        name: 'column_name',
        primaryKey: true,
      },
    ],
  },
}

Nice to Have Features

1. Drop and create sequences by synchronizing the table with force mode

2. CHECK constraint

Currently the definition of columns is an object. So the order is not really specified. I think this is an opportunity for this package to create columns in the best order so that data is packed optimally. See more information here: https://www.2ndquadrant.com/en/blog/on-rocks-and-sand/

The issue is that reordering of columns is not yet possible: https://wiki.postgresql.org/wiki/Alter_column_position For now a table has to be recreated. I think this could be an opt-in feature of this package to also do for you.

An error occurs when creating a large number of SQL queries in one transaction to update the database

• Need to group requests in small transactions

Optimize the structure and change the approach in the tests. It would be nice to check the SQL queries that were executed to update the database(after the closure of issue #79)

• remove the column.force parameter to avoid data loss
• allow changing column type only by increasing its size / precision

Planned Features

1. Ability to read the structure of existing entities

const differ = new Differ({ ... })
const schema = await differ.read.table({ name: 'public.users' })

In documentation, there is example when column can be defined as string:

description: 'character varying(255)'

This does not pass type checking based on current typing information.

When adding the identity property to a column, we need to delete the old sequence that was previously created for this column (when it had the serial type)

How to rename a column (or table)?

I think this project is great, but I could not find a way to rename a column (or table)? I think probably some option like oldNames could be provided for both columns and tables which would then rename them if Differ detects anything under the old name.

(This would not allow one to reuse the old name, but I think this is probably OK limitation for this project.)

Planned

• remove deprecated features
• add strict mode that converts warnings to errors
• add the ability to set names for constraints and indexes
• use async fs methods in differ.import()

Nice To Have

• move CLI to a separate module

While attempting to test the pg-differ cli on Macos, I ran into a env: node\r: No such file or directory error.

I was able to resolve the issue by following the instructions in this S.O. answer. The problem is apparently caused because the pg-differ CLI source code file has windows style line endings.

Need to add the ability to rename table columns

Converting values ​​without removing them when changing the type of the column 'boolean' => 'integer' and 'integer' => 'boolean'

Restart the sequence to the largest column value that uses this sequence

So I think it is OK that removed columns are kept. But they should be changed so that NULL values can be inserted into them. This means that future queries which do not know about those columns can succeed and database will just insert NULL values in their place.

The match parameter will be used to filter synchronization objects and take the regular expression as a value

const differ = new Differ({...})

differ.define('table', { name: 'contacts', columns: {...} }) // will be sync
differ.define('table', { name: 'contact_roles', columns: {...} }) // will be sync
differ.define('table', { name: 'chats', columns: {...} }) // will not sync

await differ.sync({ match: /^contact.*/ })

Need to add the .d.ts declaration file and remove the JSDoc comments

• remove the schemaFolder option
• remove the placeholders option
• remove force from constructor options
• remove the Seeds object
• remove the seeds option from Table object