fx.migrate — io.github.parencat/fx 0.1.8

->add-ddl clj

(->add-ddl entity all-columns cols-to-add)

->array-type clj

(->array-type type)

Returns supported by Postgres array type

->column-name clj

(->column-name entity field-name)

->constraint-name clj

(->constraint-name table column constraint)

->constraints-drop-ddl clj

(->constraints-drop-ddl entity columns)

Converts table fields to the list of HoneySQL drop clauses

->drop-ddl clj

(->drop-ddl entity cols-to-delete)

->set-ddl clj

(->set-ddl entity columns)

Converts table fields to the list of HoneySQL alter clauses

add-enum-value clj

(add-enum-value enum value)

alter-table-ddl clj

(alter-table-ddl table changes)

Returns HoneySQL formatted map representing alter SQL clause

apply-migrations! clj

(apply-migrations! {:keys [database entities]})

Generates and applies migrations related to entities on database All migrations run in a single transaction

clean-up-entities clj

(clean-up-entities entities)

column->constraints-map clj

(column->constraints-map {:keys [nullable pk-name fkcolumn-name pktable-name
                                 column-def non-unique delete-rule type-name]})

Convert table field map to field constraints map

column->modifiers clj

(column->modifiers entity col-name column)

Converts field to HoneySQL vector definition

column-name? clj

column-type clj

create-enum clj

(create-enum entity enum migrations)

create-enum-ddl clj

(create-enum-ddl enum values)

Returns HoneySQL formatted map representing create enum SQL clause

create-table clj

(create-table entity table migrations)

Adds two SQL commands to create DB table and to delete this table

create-table-ddl clj

(create-table-ddl table columns)

Returns HoneySQL formatted map representing create SQL clause

default-column-size clj

default-path-pattern clj

drop-enum-ddl clj

(drop-enum-ddl enum)

Returns HoneySQL formatted map representing drop enum SQL clause

drop-migrations! clj

(drop-migrations! database rollback-migrations)

Rollback all changes made by apply-migrations! call

drop-table-ddl clj

(drop-table-ddl table)

Returns HoneySQL formatted map representing drop SQL clause

ensure-type-consistent clj

(ensure-type-consistent type)

entity->columns-ddl clj

(entity->columns-ddl entity)

Converts entity spec to a list of HoneySQL vectors representing individual fields e.g. [[:id :uuid [:not nil] [:primary-key]] ...]

entity->migration clj

(entity->migration database migrations entity)

Given an entity will check if some updates were introduced If so will return a set of SQL migrations string

enum-exist? clj

(enum-exist? database enum)

extract-db-columns clj

(extract-db-columns database table)

Returns all table fields metadata

extract-default-val clj

(extract-default-val column-def)

Parse column definition and return a default value

get-all-migrations clj

(get-all-migrations database entities)

Returns a two-dimensional vector of migration strings for all changed entities. For each entity will be two items 'SQL to apply changes' followed with 'SQL to drop changes'

get-db-columns clj

(get-db-columns database table)

Fetches the table fields definition and convert them to simplified Clojure maps

get-db-enum-values clj

(get-db-enum-values database enum)

get-entity-columns clj

(get-entity-columns entity)

Given an entity will return a simplified representation of its fields as Clojure map e.g. {:id {:type uuid? :optional false :primary-key true} :name {:type string? :optional true}}

get-entity-migrations-map clj

(get-entity-migrations-map database entities)

Returns a map of shape {:entity/name {:up 'SQL to apply changes' :down 'SQL to drop changes'}}

get-ref-table clj

(get-ref-table entity field)

get-ref-type clj

(get-ref-type entity-key)

Given an entity name will find a primary key field and return its type. e.g. :my/user -> :uuid Type could be complex e.g. [:string 250]

has-changes? clj

(has-changes? db-columns entity-columns)

Given the simplified existing and updated fields definition will return true if there's a difference between them, otherwise false

has-migration? clj

(has-migration? entity)

index-by-name clj

interpolate clj

(interpolate template replacement)

Takes a template string with ${} placeholders and a hashmap with replacement values. Returns interpolated string

migratable-props clj

prep-changes clj

(prep-changes entity db-columns entity-columns)

Given the simplified existing and updated fields definition will return a set of HoneySQL clauses to eliminate the difference

prep-migrations clj

(prep-migrations database entities)

Generates migrations for all entities in the system (forward and backward)

raw-table-field clj

schema->column-modifiers clj

(schema->column-modifiers entity field-key field-schema)

Given an entity schema will return a vector of SQL field constraints, shaped as HoneySQL clauses e.g. [[:not nil] [:primary-key]]

schema->column-type clj

(schema->column-type {:keys [type props]})

Given a field type and optional properties will return a unified (simplified) type representation. Few implementation notes: interval with fields - only DAY, HOUR, MINUTE and SECOND supported due to conversion from Duration class time with timezone doesn't really work - zone part is missed somewhere in between DB and PGDriver

schema->constraints-map clj

(schema->constraints-map entry-schema)

Converts entity field spec to a map of fields constraints used primarily for diffing states e.g. {:optional false :primary-key true}

sort-by-dependencies clj

(sort-by-dependencies entities)

According to dependencies between entities will sort them in the topological order

store-migrations! clj

(store-migrations! {:keys [database entities clock path-pattern path-params]
                    :or {clock (Clock/systemUTC)}})

Writes entities migrations code into files in .edn format

table-exist? clj

(table-exist? database table)

Checks if table exists in database

table-field clj

table-field-constraints clj

table-fields clj

type-aliases clj

types-without-defaults clj

unzip clj

(unzip coll)

Reverse operation to interleave function e.g. [1 2 3 4] -> ([1 3] [2 4])

update-enum clj

(update-enum database entity enum migrations)

update-table clj

(update-table database entity table migrations)

Adds two SQL commands to update fields and to roll back all updates

validate-schema! clj

(validate-schema! {:keys [database entities]})

Compares DB schema with entities specs. Returns true if there's no changes false otherwise

vars-matcher clj

Regex that matches string template variables