dbmate 1.16.0 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Adrian Macneil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,24 +1,548 @@
 # Dbmate
 
-Nodejs wrapper for [amacneil/dbmate](https://github.com/amacneil/dbmate)
+[![Release](https://img.shields.io/github/release/amacneil/dbmate.svg)](https://github.com/amacneil/dbmate/releases)
+[![Go Report](https://goreportcard.com/badge/github.com/amacneil/dbmate)](https://goreportcard.com/report/github.com/amacneil/dbmate)
+[![Reference](https://img.shields.io/badge/go.dev-reference-blue?logo=go&logoColor=white)](https://pkg.go.dev/github.com/amacneil/dbmate/v2/pkg/dbmate)
+
+Dbmate is a database migration tool that will keep your database schema in sync across multiple developers and your production servers.
+
+It is a standalone command line tool that can be used with Go, Node.js, Python, Ruby, PHP, or any other language or framework you are using to write database-backed applications. This is especially helpful if you are writing multiple services in different languages, and want to maintain some sanity with consistent development tools.
+
+For a comparison between dbmate and other popular database schema migration tools, please see [Alternatives](#alternatives).
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Commands](#commands)
+  - [Command Line Options](#command-line-options)
+- [Usage](#usage)
+  - [Connecting to the Database](#connecting-to-the-database)
+    - [PostgreSQL](#postgresql)
+    - [MySQL](#mysql)
+    - [SQLite](#sqlite)
+    - [ClickHouse](#clickhouse)
+  - [Creating Migrations](#creating-migrations)
+  - [Running Migrations](#running-migrations)
+  - [Rolling Back Migrations](#rolling-back-migrations)
+  - [Migration Options](#migration-options)
+  - [Waiting For The Database](#waiting-for-the-database)
+  - [Exporting Schema File](#exporting-schema-file)
+- [Library](#library)
+  - [Use dbmate as a library](#use-dbmate-as-a-library)
+  - [Embedding migrations](#embedding-migrations)
+- [Concepts](#concepts)
+  - [Migration files](#migration-files)
+  - [Schema file](#schema-file)
+  - [Schema migrations table](#schema-migrations-table)
+- [Alternatives](#alternatives)
+- [Contributing](#contributing)
+
+## Features
+
+- Supports MySQL, PostgreSQL, SQLite, and ClickHouse.
+- Uses plain SQL for writing schema migrations.
+- Migrations are timestamp-versioned, to avoid version number conflicts with multiple developers.
+- Migrations are run atomically inside a transaction.
+- Supports creating and dropping databases (handy in development/test).
+- Supports saving a `schema.sql` file to easily diff schema changes in git.
+- Database connection URL is defined using an environment variable (`DATABASE_URL` by default), or specified on the command line.
+- Built-in support for reading environment variables from your `.env` file.
+- Easy to distribute, single self-contained binary.
+
+## Installation
+
+**NPM**
+
+Install using [NPM](https://www.npmjs.com/):
+
+```sh
+$ npm install --save-dev dbmate
+$ npx dbmate --help
+```
+
+**macOS**
+
+Install using [Homebrew](https://brew.sh/):
+
+```sh
+$ brew install dbmate
+```
+
+**Linux**
+
+Install the binary directly:
+
+```sh
+$ sudo curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
+$ sudo chmod +x /usr/local/bin/dbmate
+```
+
+**Windows**
+
+Install using [Scoop](https://scoop.sh)
+
+```pwsh
+scoop install dbmate
+```
+
+**Docker**
+
+Docker images are published to both Docker Hub ([`amacneil/dbmate`](https://hub.docker.com/r/amacneil/dbmate)) and Github Container Registry ([`ghcr.io/amacneil/dbmate`](https://ghcr.io/amacneil/dbmate)).
+
+Remember to set `--network=host` or see [this comment](https://github.com/amacneil/dbmate/issues/128#issuecomment-615924611) for more tips on using dbmate with docker networking):
+
+```sh
+$ docker run --rm -it --network=host ghcr.io/amacneil/dbmate --help
+```
+
+If you wish to create or apply migrations, you will need to use Docker's [bind mount](https://docs.docker.com/storage/bind-mounts/) feature to make your local working directory (`pwd`) available inside the dbmate container:
+
+```sh
+$ docker run --rm -it --network=host -v "$(pwd)/db:/db" ghcr.io/amacneil/dbmate new create_users_table
+```
+
+**Heroku**
+
+To use dbmate on Heroku, either use the NPM method, or store the linux binary in your git repository:
+
+```sh
+$ mkdir -p bin
+$ curl -fsSL -o bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
+$ chmod +x bin/dbmate
+$ git add bin/dbmate
+$ git commit -m "Add dbmate binary"
+$ git push heroku master
+$ heroku run bin/dbmate --help
+```
+
+## Commands
+
+```sh
+dbmate --help    # print usage help
+dbmate new       # generate a new migration file
+dbmate up        # create the database (if it does not already exist) and run any pending migrations
+dbmate create    # create the database
+dbmate drop      # drop the database
+dbmate migrate   # run any pending migrations
+dbmate rollback  # roll back the most recent migration
+dbmate down      # alias for rollback
+dbmate status    # show the status of all migrations (supports --exit-code and --quiet)
+dbmate dump      # write the database schema.sql file
+dbmate wait      # wait for the database server to become available
+```
+
+### Command Line Options
+
+The following options are available with all commands. You must use command line arguments in the order `dbmate [global options] command [command options]`. Most options can also be configured via environment variables (and loaded from your `.env` file, which is helpful to share configuration between team members).
+
+- `--url, -u "protocol://host:port/dbname"` - specify the database url directly. _(env: `DATABASE_URL`)_
+- `--env, -e "DATABASE_URL"` - specify an environment variable to read the database connection URL from.
+- `--migrations-dir, -d "./db/migrations"` - where to keep the migration files. _(env: `DBMATE_MIGRATIONS_DIR`)_
+- `--migrations-table "schema_migrations"` - database table to record migrations in. _(env: `DBMATE_MIGRATIONS_TABLE`)_
+- `--schema-file, -s "./db/schema.sql"` - a path to keep the schema.sql file. _(env: `DBMATE_SCHEMA_FILE`)_
+- `--no-dump-schema` - don't auto-update the schema.sql file on migrate/rollback _(env: `DBMATE_NO_DUMP_SCHEMA`)_
+- `--wait` - wait for the db to become available before executing the subsequent command _(env: `DBMATE_WAIT`)_
+- `--wait-timeout 60s` - timeout for --wait flag _(env: `DBMATE_WAIT_TIMEOUT`)_
+
+## Usage
+
+### Connecting to the Database
+
+Dbmate locates your database using the `DATABASE_URL` environment variable by default. If you are writing a [twelve-factor app](http://12factor.net/), you should be storing all connection strings in environment variables.
+
+To make this easy in development, dbmate looks for a `.env` file in the current directory, and treats any variables listed there as if they were specified in the current environment (existing environment variables take preference, however).
+
+If you do not already have a `.env` file, create one and add your database connection URL:
+
+```sh
+$ cat .env
+DATABASE_URL="postgres://postgres@127.0.0.1:5432/myapp_development?sslmode=disable"
+```
+
+`DATABASE_URL` should be specified in the following format:
+
+```
+protocol://username:password@host:port/database_name?options
+```
+
+- `protocol` must be one of `mysql`, `postgres`, `postgresql`, `sqlite`, `sqlite3`, `clickhouse`
+- `host` can be either a hostname or IP address
+- `options` are driver-specific (refer to the underlying Go SQL drivers if you wish to use these)
+
+Dbmate can also load the connection URL from a different environment variable. For example, before running your test suite, you may wish to drop and recreate the test database. One easy way to do this is to store your test database connection URL in the `TEST_DATABASE_URL` environment variable:
+
+```sh
+$ cat .env
+DATABASE_URL="postgres://postgres@127.0.0.1:5432/myapp_dev?sslmode=disable"
+TEST_DATABASE_URL="postgres://postgres@127.0.0.1:5432/myapp_test?sslmode=disable"
+```
+
+You can then specify this environment variable in your test script (Makefile or similar):
+
+```sh
+$ dbmate -e TEST_DATABASE_URL drop
+Dropping: myapp_test
+$ dbmate -e TEST_DATABASE_URL --no-dump-schema up
+Creating: myapp_test
+Applying: 20151127184807_create_users_table.sql
+```
+
+Alternatively, you can specify the url directly on the command line:
+
+```sh
+$ dbmate -u "postgres://postgres@127.0.0.1:5432/myapp_test?sslmode=disable" up
+```
+
+The only advantage of using `dbmate -e TEST_DATABASE_URL` over `dbmate -u $TEST_DATABASE_URL` is that the former takes advantage of dbmate's automatic `.env` file loading.
+
+#### PostgreSQL
+
+When connecting to Postgres, you may need to add the `sslmode=disable` option to your connection string, as dbmate by default requires a TLS connection (some other frameworks/languages allow unencrypted connections by default).
+
+```sh
+DATABASE_URL="postgres://username:password@127.0.0.1:5432/database_name?sslmode=disable"
+```
+
+A `socket` or `host` parameter can be specified to connect through a unix socket (note: specify the directory only):
+
+```sh
+DATABASE_URL="postgres://username:password@/database_name?socket=/var/run/postgresql"
+```
+
+A `search_path` parameter can be used to specify the [current schema](https://www.postgresql.org/docs/13/ddl-schemas.html#DDL-SCHEMAS-PATH) while applying migrations, as well as for dbmate's `schema_migrations` table.
+If the schema does not exist, it will be created automatically. If multiple comma-separated schemas are passed, the first will be used for the `schema_migrations` table.
+
+```sh
+DATABASE_URL="postgres://username:password@127.0.0.1:5432/database_name?search_path=myschema"
+```
+
+```sh
+DATABASE_URL="postgres://username:password@127.0.0.1:5432/database_name?search_path=myschema,public"
+```
+
+#### MySQL
+
+```sh
+DATABASE_URL="mysql://username:password@127.0.0.1:3306/database_name"
+```
+
+A `socket` parameter can be specified to connect through a unix socket:
+
+```sh
+DATABASE_URL="mysql://username:password@/database_name?socket=/var/run/mysqld/mysqld.sock"
+```
+
+#### SQLite
+
+SQLite databases are stored on the filesystem, so you do not need to specify a host. By default, files are relative to the current directory. For example, the following will create a database at `./db/database.sqlite3`:
+
+```sh
+DATABASE_URL="sqlite:db/database.sqlite3"
+```
+
+To specify an absolute path, add a forward slash to the path. The following will create a database at `/tmp/database.sqlite3`:
+
+```sh
+DATABASE_URL="sqlite:/tmp/database.sqlite3"
+```
+
+#### ClickHouse
+
+```sh
+DATABASE_URL="clickhouse://username:password@127.0.0.1:9000/database_name"
+```
+
+[See other supported connection options](https://github.com/ClickHouse/clickhouse-go#dsn).
+
+### Creating Migrations
+
+To create a new migration, run `dbmate new create_users_table`. You can name the migration anything you like. This will create a file `db/migrations/20151127184807_create_users_table.sql` in the current directory:
+
+```sql
+-- migrate:up
+
+-- migrate:down
+```
+
+To write a migration, simply add your SQL to the `migrate:up` section:
+
+```sql
+-- migrate:up
+create table users (
+  id integer,
+  name varchar(255),
+  email varchar(255) not null
+);
+
+-- migrate:down
+```
+
+> Note: Migration files are named in the format `[version]_[description].sql`. Only the version (defined as all leading numeric characters in the file name) is recorded in the database, so you can safely rename a migration file without having any effect on its current application state.
+
+### Running Migrations
+
+Run `dbmate up` to run any pending migrations.
+
+```sh
+$ dbmate up
+Creating: myapp_development
+Applying: 20151127184807_create_users_table.sql
+Writing: ./db/schema.sql
+```
+
+> Note: `dbmate up` will create the database if it does not already exist (assuming the current user has permission to create databases). If you want to run migrations without creating the database, run `dbmate migrate`.
+
+Pending migrations are always applied in numerical order. However, dbmate does not prevent migrations from being applied out of order if they are committed independently (for example: if a developer has been working on a branch for a long time, and commits a migration which has a lower version number than other already-applied migrations, dbmate will simply apply the pending migration). See [#159](https://github.com/amacneil/dbmate/issues/159) for a more detailed explanation.
+
+### Rolling Back Migrations
+
+By default, dbmate doesn't know how to roll back a migration. In development, it's often useful to be able to revert your database to a previous state. To accomplish this, implement the `migrate:down` section:
+
+```sql
+-- migrate:up
+create table users (
+  id integer,
+  name varchar(255),
+  email varchar(255) not null
+);
+
+-- migrate:down
+drop table users;
+```
+
+Run `dbmate rollback` to roll back the most recent migration:
+
+```sh
+$ dbmate rollback
+Rolling back: 20151127184807_create_users_table.sql
+Writing: ./db/schema.sql
+```
+
+### Migration Options
+
+dbmate supports options passed to a migration block in the form of `key:value` pairs. List of supported options:
+
+- `transaction`
+
+**transaction**
+
+`transaction` is useful if you need to run some SQL which cannot be executed from within a transaction. For example, in Postgres, you would need to disable transactions for migrations that alter an enum type to add a value:
+
+```sql
+-- migrate:up transaction:false
+ALTER TYPE colors ADD VALUE 'orange' AFTER 'red';
+```
+
+`transaction` will default to `true` if your database supports it.
+
+### Waiting For The Database
+
+If you use a Docker development environment for your project, you may encounter issues with the database not being immediately ready when running migrations or unit tests. This can be due to the database server having only just started.
+
+In general, your application should be resilient to not having a working database connection on startup. However, for the purpose of running migrations or unit tests, this is not practical. The `wait` command avoids this situation by allowing you to pause a script or other application until the database is available. Dbmate will attempt a connection to the database server every second, up to a maximum of 60 seconds.
+
+If the database is available, `wait` will return no output:
+
+```sh
+$ dbmate wait
+```
+
+If the database is unavailable, `wait` will block until the database becomes available:
+
+```sh
+$ dbmate wait
+Waiting for database....
+```
+
+You can also use the `--wait` flag with other commands if you sometimes see failures caused by the database not yet being ready:
+
+```sh
+$ dbmate --wait up
+Waiting for database....
+Creating: myapp_development
+```
+
+You can customize the timeout using `--wait-timeout` (default 60s). If the database is still not available, the command will return an error:
+
+```sh
+$ dbmate --wait-timeout=5s wait
+Waiting for database.....
+Error: unable to connect to database: dial tcp 127.0.0.1:5432: connect: connection refused
+```
+
+Please note that the `wait` command does not verify whether your specified database exists, only that the server is available and ready (so it will return success if the database server is available, but your database has not yet been created).
+
+### Exporting Schema File
+
+When you run the `up`, `migrate`, or `rollback` commands, dbmate will automatically create a `./db/schema.sql` file containing a complete representation of your database schema. Dbmate keeps this file up to date for you, so you should not manually edit it.
+
+It is recommended to check this file into source control, so that you can easily review changes to the schema in commits or pull requests. It's also possible to use this file when you want to quickly load a database schema, without running each migration sequentially (for example in your test harness). However, if you do not wish to save this file, you could add it to your `.gitignore`, or pass the `--no-dump-schema` command line option.
+
+To dump the `schema.sql` file without performing any other actions, run `dbmate dump`. Unlike other dbmate actions, this command relies on the respective `pg_dump`, `mysqldump`, or `sqlite3` commands being available in your PATH. If these tools are not available, dbmate will silenty skip the schema dump step during `up`, `migrate`, or `rollback` actions. You can diagnose the issue by running `dbmate dump` and looking at the output:
+
+```sh
+$ dbmate dump
+exec: "pg_dump": executable file not found in $PATH
+```
+
+On Ubuntu or Debian systems, you can fix this by installing `postgresql-client`, `mysql-client`, or `sqlite3` respectively. Ensure that the package version you install is greater than or equal to the version running on your database server.
+
+> Note: The `schema.sql` file will contain a complete schema for your database, even if some tables or columns were created outside of dbmate migrations.
 
 ## Library
 
-```typescript
-import { DbMate } from 'dbmate';
+### Use dbmate as a library
+
+Dbmate is designed to be used as a CLI with any language or framework, but it can also be used as a library in a Go application.
+
+Here is a simple example. Remember to import the driver you need!
+
+```go
+package main
+
+import (
+	"net/url"
+
+	"github.com/amacneil/dbmate/v2/pkg/dbmate"
+	_ "github.com/amacneil/dbmate/v2/pkg/driver/sqlite"
+)
+
+func main() {
+	u, _ := url.Parse("sqlite:foo.sqlite3")
+	db := dbmate.New(u)
+
+	err := db.CreateAndMigrate()
+	if err != nil {
+		panic(err)
+	}
+}
+```
+
+See the [reference documentation](https://pkg.go.dev/github.com/amacneil/dbmate/v2/pkg/dbmate) for more options.
+
+### Embedding migrations
+
+Migrations can be embedded into your application binary using Go's [embed](https://pkg.go.dev/embed) functionality.
+
+Use `db.FS` to specify the filesystem used for reading migrations:
+
+```go
+package main
 
-// construct a dbmate instance using a database url string
-// see https://github.com/amacneil/dbmate#usage for more details
-const dbmate = new DbMate('db://user:pass@host:port/db?opt');
+import (
+	"embed"
+	"fmt"
+	"net/url"
 
-// invoke up, down, drop as necessary
-await dbmate.up();
+	"github.com/amacneil/dbmate/v2/pkg/dbmate"
+	_ "github.com/amacneil/dbmate/v2/pkg/driver/sqlite"
+)
+
+//go:embed db/migrations/*.sql
+var fs embed.FS
+
+func main() {
+	u, _ := url.Parse("sqlite:foo.sqlite3")
+	db := dbmate.New(u)
+	db.FS = fs
+
+	fmt.Println("Migrations:")
+	migrations, err := db.FindMigrations()
+	if err != nil {
+		panic(err)
+	}
+	for _, m := range migrations {
+		fmt.Println(m.Version, m.FilePath)
+	}
+
+	fmt.Println("\nApplying...")
+	err = db.CreateAndMigrate()
+	if err != nil {
+		panic(err)
+	}
+}
 ```
 
-## CLI
+## Concepts
+
+### Migration files
 
-The `dbmate` cli wraps the precompiled dbmate binaries and passes all command line options. The cli wrapper will detect the appropriate binary for your system.
+Migration files are very simple, and are stored in `./db/migrations` by default. You can create a new migration file named `[date]_create_users.sql` by running `dbmate new create_users`.
+Here is an example:
 
-## License
+```sql
+-- migrate:up
+create table users (
+  id integer,
+  name varchar(255),
+);
 
-See LICENSE.md
+-- migrate:down
+drop table if exists users;
+```
+
+Both up and down migrations are stored in the same file, for ease of editing. Both up and down directives are required, even if you choose not to implement the down migration.
+
+When you apply a migration dbmate only stores the version number, not the contents, so you should always rollback a migration before modifying its contents. For this reason, you can safely rename a migration file without affecting its applied status, as long as you keep the version number intact.
+
+### Schema file
+
+The schema file is written to `./db/schema.sql` by default. It is a complete dump of your database schema, including any applied migrations, and any other modifications you have made.
+
+This file should be checked in to source control, so that you can easily compare the diff of a migration. You can use the schema file to quickly restore your database without needing to run all migrations.
+
+### Schema migrations table
+
+Dbmate stores a record of each applied migration in table named `schema_migrations`. This table will be created for you automatically if it does not already exist.
+
+The table is very simple:
+
+```sql
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version VARCHAR(255) PRIMARY KEY
+)
+```
+
+You can customize the name of this table using the `--migrations-table` flag or `DBMATE_MIGRATIONS_TABLE` environment variable.
+
+## Alternatives
+
+Why another database schema migration tool? Dbmate was inspired by many other tools, primarily [Active Record Migrations](http://guides.rubyonrails.org/active_record_migrations.html), with the goals of being trivial to configure, and language & framework independent. Here is a comparison between dbmate and other popular migration tools.
+
+|                                                              | [dbmate](https://github.com/amacneil/dbmate) | [goose](https://github.com/pressly/goose) | [sql-migrate](https://github.com/rubenv/sql-migrate) | [golang-migrate](https://github.com/golang-migrate/migrate) | [activerecord](http://guides.rubyonrails.org/active_record_migrations.html) | [sequelize](http://docs.sequelizejs.com/manual/tutorial/migrations.html) | [flyway](https://flywaydb.org/) |
+| ------------------------------------------------------------ | :------------------------------------------: | :---------------------------------------: | :--------------------------------------------------: | :---------------------------------------------------------: | :-------------------------------------------------------------------------: | :----------------------------------------------------------------------: | :-----------------------------: |
+| **Features**                                                 |
+| Plain SQL migration files                                    |              :white_check_mark:              |            :white_check_mark:             |                  :white_check_mark:                  |                     :white_check_mark:                      |                                                                             |                                                                          |       :white_check_mark:        |
+| Support for creating and dropping databases                  |              :white_check_mark:              |                                           |                                                      |                                                             |                             :white_check_mark:                              |                                                                          |                                 |
+| Support for saving schema dump files                         |              :white_check_mark:              |                                           |                                                      |                                                             |                             :white_check_mark:                              |                                                                          |                                 |
+| Timestamp-versioned migration files                          |              :white_check_mark:              |            :white_check_mark:             |                                                      |                     :white_check_mark:                      |                             :white_check_mark:                              |                            :white_check_mark:                            |                                 |
+| Custom schema migrations table                               |              :white_check_mark:              |                                           |                  :white_check_mark:                  |                                                             |                                                                             |                            :white_check_mark:                            |       :white_check_mark:        |
+| Ability to wait for database to become ready                 |              :white_check_mark:              |                                           |                                                      |                                                             |                                                                             |                                                                          |                                 |
+| Database connection string loaded from environment variables |              :white_check_mark:              |                                           |                                                      |                                                             |                                                                             |                                                                          |       :white_check_mark:        |
+| Automatically load .env file                                 |              :white_check_mark:              |                                           |                                                      |                                                             |                                                                             |                                                                          |                                 |
+| No separate configuration file                               |              :white_check_mark:              |                                           |                                                      |                     :white_check_mark:                      |                             :white_check_mark:                              |                            :white_check_mark:                            |                                 |
+| Language/framework independent                               |              :white_check_mark:              |            :white_check_mark:             |                                                      |                     :white_check_mark:                      |                                                                             |                                                                          |       :white_check_mark:        |
+| **Drivers**                                                  |
+| PostgreSQL                                                   |              :white_check_mark:              |            :white_check_mark:             |                  :white_check_mark:                  |                     :white_check_mark:                      |                             :white_check_mark:                              |                            :white_check_mark:                            |       :white_check_mark:        |
+| MySQL                                                        |              :white_check_mark:              |            :white_check_mark:             |                  :white_check_mark:                  |                     :white_check_mark:                      |                             :white_check_mark:                              |                            :white_check_mark:                            |       :white_check_mark:        |
+| SQLite                                                       |              :white_check_mark:              |            :white_check_mark:             |                  :white_check_mark:                  |                     :white_check_mark:                      |                             :white_check_mark:                              |                            :white_check_mark:                            |       :white_check_mark:        |
+| CliсkHouse                                                   |              :white_check_mark:              |                                           |                                                      |                     :white_check_mark:                      |                             :white_check_mark:                              |                            :white_check_mark:                            |                                 |
+
+_If you notice any inaccuracies in this table, please [propose a change](https://github.com/amacneil/dbmate/edit/main/README.md)._
+
+## Contributing
+
+Dbmate is written in Go, pull requests are welcome.
+
+Tests are run against a real database using docker-compose. To build a docker image and run the tests:
+
+```sh
+$ make docker-all
+```
+
+To start a development shell:
+
+```sh
+$ make docker-sh
+```

package/bin/dbmate.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const { arch, platform } = require("process");
+const { realpathSync } = require("fs");
+const { spawnSync } = require("child_process");
+const { fileURLToPath } = require("url");
+const { dirname } = require("path");
+
+const packageName = `@dbmate/${platform}-${arch}`;
+const binName = platform === "win32" ? "dbmate.exe" : "dbmate";
+let binPath = `${packageName}/bin/${binName}`;
+
+try {
+  binPath = require.resolve(binPath);
+} catch (error) {
+  console.error(`Error: Unable to locate package ${packageName}`);
+  process.exit(1);
+}
+
+const child = spawnSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+process.exit(child.status);

package/package.json

@@ -1,34 +1,29 @@
 {
   "name": "dbmate",
-  "version": "1.16.0",
-  "scripts": {
-    "build": "tsc",
-    "build:docs": "typedoc ./src/*.ts",
-    "prepublish": "npm run build",
-    "test": "jest",
-    "prettier:check": "prettier --check 'src/**/*.ts' 'spec/**/*.ts'",
-    "prettier:fix": "prettier --write 'src/**/*.ts' 'spec/**/*.ts'",
-    "lint": "npm run prettier:check"
-  },
-  "repository": "gitlab:defunctzombie/node-dbmate",
-  "main": "dist/index.js",
+  "version": "2.0.0",
+  "description": "A lightweight, framework-agnostic database migration tool",
+  "repository": "https://github.com/amacneil/dbmate",
+  "homepage": "https://github.com/amacneil/dbmate#readme",
+  "author": "Adrian Macneil",
+  "license": "MIT",
+  "keywords": [
+    "clickhouse",
+    "database",
+    "migration",
+    "mysql",
+    "postgres",
+    "schema",
+    "sqlite"
+  ],
   "bin": {
-    "dbmate": "dist/cli.js"
+    "dbmate": "bin/dbmate.js"
   },
-  "files": [
-    "yarn.lock",
-    "package.json",
-    "binaries",
-    "dist",
-    "LICENSE.md",
-    "README.md"
-  ],
-  "devDependencies": {
-    "@types/jest": "25.1.4",
-    "@types/node": "13.9.0",
-    "jest": "25.1.0",
-    "prettier": "1.19.1",
-    "ts-jest": "25.2.1",
-    "typescript": "3.8.3"
+  "optionalDependencies": {
+    "@dbmate/linux-x64": "2.0.0",
+    "@dbmate/linux-arm64": "2.0.0",
+    "@dbmate/linux-arm": "2.0.0",
+    "@dbmate/darwin-x64": "2.0.0",
+    "@dbmate/darwin-arm64": "2.0.0",
+    "@dbmate/win32-x64": "2.0.0"
   }
-}
+}

package/LICENSE.md

@@ -1,55 +0,0 @@
-# Blue Oak Model License
-
-Version 1.0.0
-
-## Purpose
-
-This license gives everyone as much permission to work with
-this software as possible, while protecting contributors
-from liability.
-
-## Acceptance
-
-In order to receive this license, you must agree to its
-rules.  The rules of this license are both obligations
-under that agreement and conditions to your license.
-You must not do anything with this software that triggers
-a rule that you cannot or will not follow.
-
-## Copyright
-
-Each contributor licenses you to do everything with this
-software that would otherwise infringe that contributor's
-copyright in it.
-
-## Notices
-
-You must ensure that everyone who gets a copy of
-any part of this software from you, with or without
-changes, also gets the text of this license or a link to
-<https://blueoakcouncil.org/license/1.0.0>.
-
-## Excuse
-
-If anyone notifies you in writing that you have not
-complied with [Notices](#notices), you can keep your
-license by taking all practical steps to comply within 30
-days after the notice.  If you do not do so, your license
-ends immediately.
-
-## Patent
-
-Each contributor licenses you to do everything with this
-software that would otherwise infringe any patent claims
-they can license or become able to license.
-
-## Reliability
-
-No contributor can revoke this license.
-
-## No Liability
-
-***As far as the law allows, this software comes as is,
-without any warranty or condition, and no contributor
-will be liable to anyone for any damages related to this
-software or this license, under any kind of legal claim.***

package/dist/DbMate.d.ts

@@ -1,14 +0,0 @@
-declare type Args = {
-    migrationsDir?: string;
-};
-declare class DbMate {
-    private binaryPath;
-    private dbUrl;
-    private args;
-    constructor(dbUrl: string, args?: Args);
-    up(): Promise<void>;
-    down(): Promise<void>;
-    drop(): Promise<void>;
-    private buildCliArgs;
-}
-export default DbMate;

package/dist/DbMate.js

@@ -1,100 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var child_process_1 = require("child_process");
-var resolve_1 = require("./resolve");
-var DbMate = /** @class */ (function () {
-    function DbMate(dbUrl, args) {
-        this.binaryPath = resolve_1.calculateBinaryPath();
-        this.dbUrl = dbUrl;
-        this.args = args;
-    }
-    DbMate.prototype.up = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var cmd;
-            return __generator(this, function (_a) {
-                cmd = this.binaryPath + " --env DB_URL " + this.buildCliArgs() + " up";
-                child_process_1.execSync(cmd, {
-                    env: {
-                        DB_URL: this.dbUrl,
-                    },
-                });
-                return [2 /*return*/];
-            });
-        });
-    };
-    DbMate.prototype.down = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var cmd;
-            return __generator(this, function (_a) {
-                cmd = this.binaryPath + " --env DB_URL " + this.buildCliArgs() + " down";
-                child_process_1.execSync(cmd, {
-                    env: {
-                        DB_URL: this.dbUrl,
-                    },
-                });
-                return [2 /*return*/];
-            });
-        });
-    };
-    DbMate.prototype.drop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var cmd;
-            return __generator(this, function (_a) {
-                cmd = this.binaryPath + " --env DB_URL " + this.buildCliArgs() + " drop";
-                child_process_1.execSync(cmd, {
-                    env: {
-                        DB_URL: this.dbUrl,
-                    },
-                });
-                return [2 /*return*/];
-            });
-        });
-    };
-    DbMate.prototype.buildCliArgs = function () {
-        var _a;
-        // additional cli args
-        var cliArgs = [];
-        if (((_a = this.args) === null || _a === void 0 ? void 0 : _a.migrationsDir) != undefined) {
-            cliArgs.push("-d \"" + this.args.migrationsDir + "\"");
-        }
-        return cliArgs.join(' ');
-    };
-    return DbMate;
-}());
-exports.default = DbMate;

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var resolve_1 = require("./resolve");
-var child_process_1 = require("child_process");
-var binaryPath = resolve_1.calculateBinaryPath();
-var args = process.argv.slice(2);
-var ps = child_process_1.spawn(binaryPath, args, {
-    stdio: 'inherit',
-});
-ps.on('close', function (code) {
-    process.exit(code);
-});

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import DbMate from './DbMate';
-export { DbMate };

package/dist/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var DbMate_1 = require("./DbMate");
-exports.DbMate = DbMate_1.default;

package/dist/resolve.d.ts

@@ -1,3 +0,0 @@
-/** Return a path to the dbmate binary */
-declare function calculateBinaryPath(): string;
-export { calculateBinaryPath };

package/dist/resolve.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var path_1 = require("path");
-var fs_1 = require("fs");
-function archName() {
-    switch (process.arch) {
-        case 'x64':
-            return 'amd64';
-        case 'arm64':
-            return 'arm64';
-        default:
-            throw new Error("Unsupported architecture " + process.arch);
-    }
-}
-function platformName() {
-    switch (process.platform) {
-        case 'darwin':
-            return 'macos';
-        case 'linux':
-            return 'linux';
-        default:
-            throw new Error("Unsupported platform: " + process.platform);
-    }
-}
-/** Return a path to the dbmate binary */
-function calculateBinaryPath() {
-    var binaryName = "dbmate-" + platformName() + "-" + archName();
-    var binaryPath = path_1.join(__dirname, '..', 'binaries', binaryName);
-    if (!fs_1.existsSync(binaryPath)) {
-        throw new Error("Could not locate binary: " + binaryPath);
-    }
-    return binaryPath;
-}
-exports.calculateBinaryPath = calculateBinaryPath;