@biorate/migrations 1.165.14 → 2.0.0

package/index.d.ts

@@ -1,26 +0,0 @@
-import { promises as fs } from 'fs';
-import { Core, inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-import * as Migrations from './src/types';
-
-declare module '@biorate/migrations' {
-  export class Root extends Core() {
-    public config: IConfig;
-    public sequelize: Migrations.Sequelize;
-    protected initialize(): Promise<void>;
-  }
-
-  export abstract class Migration {
-    protected config: IConfig;
-    protected get type(): string;
-    protected scan(...args: string[]): Promise<string[]>;
-    protected path(...args: string[]): string;
-    protected log(...args: string[]): void;
-    protected initialize(): Promise<void>;
-    protected abstract process(): Promise<void>;
-  }
-
-  export class Sequelize extends Migration {
-    protected process(): Promise<void>;
-  }
-}

package/index.ts

@@ -1 +0,0 @@
-export * from './src';

package/src/default.config.ts

@@ -1,4 +0,0 @@
-import { container } from '@biorate/inversion';
-import { Root } from './';
-
-container.get<Root>(Root).$run().catch(console.error);

package/src/errors.ts

@@ -1,9 +0,0 @@
-import { BaseError } from '@biorate/errors';
-
-export class SchemaRegistryWrongFileNameError extends BaseError {
-  public constructor(name: string) {
-    super(`Schema registry wrong filename: [%s], pattern: "00001_filename.avsc.json"`, [
-      name,
-    ]);
-  }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './root';
-export * from './types/migration';
-export * from './types';
-
-require(process.env.MIGRATIONS_CONFIG
-  ? process.cwd() + process.env.MIGRATIONS_CONFIG
-  : './default.config');
-require(process.env.MIGRATIONS_ROOT
-  ? process.cwd() + process.env.MIGRATIONS_ROOT
-  : './root');

package/src/root.ts

@@ -1,100 +0,0 @@
-import { EventEmitter } from 'events';
-import { init, injectable, inject, Types, Core, container } from '@biorate/inversion';
-import { Config, IConfig } from '@biorate/config';
-import { ConfigLoader } from '@biorate/config-loader';
-import { IVaultConnector, VaultConnector } from '@biorate/vault';
-import { IProxyConnector, ProxyConnector } from '@biorate/proxy';
-import * as Migrations from './types';
-import { ConfigLoaderEnv } from '@biorate/config-loader-env';
-import { ConfigLoaderFs } from '@biorate/config-loader-fs';
-import { ConfigLoaderVault } from '@biorate/config-loader-vault';
-import { ISequelizeConnector, SequelizeConnector } from '@biorate/sequelize';
-import { IMinioConnector, MinioConnector } from '@biorate/minio';
-import { IMongoDBConnector, MongoDBConnector } from '@biorate/mongodb';
-import { ClickhouseConnector, IClickhouseConnector } from '@biorate/clickhouse';
-import { AmqpConnector, IAmqpConnector } from '@biorate/amqp';
-import { IKafkaJSAdminConnector, KafkaJSAdminConnector } from '@biorate/kafkajs';
-import {
-  ISchemaRegistryConnector,
-  SchemaRegistryConnector,
-} from '@biorate/schema-registry';
-
-@injectable()
-export class Root extends Core(EventEmitter) {
-  @inject(Types.Config) public readonly config: IConfig;
-
-  @inject(Types.ConfigLoaderEnv) public readonly configLoaderEnv: ConfigLoader;
-
-  @inject(Types.ConfigLoaderFs) public readonly configLoaderFs: ConfigLoader;
-
-  @inject(Types.ConfigLoaderVault) public readonly configLoaderVault: ConfigLoader;
-
-  @inject(Types.Vault) public readonly vault: IVaultConnector;
-
-  @inject(Types.Proxy) public readonly proxy: IProxyConnector;
-
-  @inject(Migrations.Sequelize) public readonly sequelize: Migrations.Sequelize;
-
-  @inject(Migrations.Minio) public readonly minio: Migrations.Minio;
-
-  @inject(Migrations.Mongodb) public readonly mongodb: Migrations.Mongodb;
-
-  @inject(Migrations.Kafka) public readonly kafkaJSAdmin: Migrations.Kafka;
-
-  @inject(Migrations.Clickhouse) public readonly clickhouse: Migrations.Clickhouse;
-
-  @inject(Migrations.Amqp) public readonly amqp: Migrations.Amqp;
-
-  @inject(Migrations.SchemaRegistry)
-  public readonly schemaRegistry: Migrations.SchemaRegistry;
-
-  @init() protected async initialize() {
-    process.exit(0);
-  }
-}
-
-// @ts-ignore
-Core.log = null;
-
-container.bind<IConfig>(Types.Config).to(Config).inSingletonScope();
-container
-  .bind<ConfigLoader>(Types.ConfigLoaderEnv)
-  .to(ConfigLoaderEnv)
-  .inSingletonScope();
-container.bind<ConfigLoader>(Types.ConfigLoaderFs).to(ConfigLoaderFs).inSingletonScope();
-container
-  .bind<ConfigLoader>(Types.ConfigLoaderVault)
-  .to(ConfigLoaderVault)
-  .inSingletonScope();
-container.bind<IVaultConnector>(Types.Vault).to(VaultConnector).inSingletonScope();
-container
-  .bind<ISequelizeConnector>(Types.Sequelize)
-  .to(SequelizeConnector)
-  .inSingletonScope();
-container.bind<IMinioConnector>(Types.Minio).to(MinioConnector).inSingletonScope();
-container.bind<IMongoDBConnector>(Types.Mongodb).to(MongoDBConnector).inSingletonScope();
-container
-  .bind<IClickhouseConnector>(Types.Clickhouse)
-  .to(ClickhouseConnector)
-  .inSingletonScope();
-container.bind<IAmqpConnector>(Types.Amqp).to(AmqpConnector).inSingletonScope();
-container
-  .bind<IKafkaJSAdminConnector>(Types.Kafka)
-  .to(KafkaJSAdminConnector)
-  .inSingletonScope();
-container.bind<IProxyConnector>(Types.Proxy).to(ProxyConnector).inSingletonScope();
-container
-  .bind<ISchemaRegistryConnector>(Types.SchemaRegistry)
-  .to(SchemaRegistryConnector)
-  .inSingletonScope();
-container.bind<Migrations.Sequelize>(Migrations.Sequelize).toSelf().inSingletonScope();
-container.bind<Migrations.Minio>(Migrations.Minio).toSelf().inSingletonScope();
-container.bind<Migrations.Mongodb>(Migrations.Mongodb).toSelf().inSingletonScope();
-container.bind<Migrations.Kafka>(Migrations.Kafka).toSelf().inSingletonScope();
-container.bind<Migrations.Clickhouse>(Migrations.Clickhouse).toSelf().inSingletonScope();
-container.bind<Migrations.Amqp>(Migrations.Amqp).toSelf().inSingletonScope();
-container
-  .bind<Migrations.SchemaRegistry>(Migrations.SchemaRegistry)
-  .toSelf()
-  .inSingletonScope();
-container.bind<Root>(Root).to(Root).inSingletonScope();

package/src/types/amqp.ts

@@ -1,46 +0,0 @@
-import { inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-import {
-  IAmqpConnector,
-  IAmqpConfig,
-  IAmqpConnection,
-  ChannelWrapper,
-  CreateChannelOpts,
-} from '@biorate/amqp';
-import { Migration } from './migration';
-/**
- * @description Amqp migration class
- */
-export class Amqp extends Migration {
-  @inject(Types.Amqp) protected connector: IAmqpConnector;
-  /**
-   * @description Amqp process method realization
-   */
-  protected async process() {
-    await this.forEach<IAmqpConfig, IAmqpConnection>(
-      'Amqp',
-      async (config, connection, paths) => {
-        const channel = connection.createChannel(
-          this.config.get<CreateChannelOpts>(
-            `migrations.Amqp.${config.name}.amqpChannelOptions`,
-            {},
-          ),
-        );
-        await channel.waitForConnect();
-        await this.forEachPath(paths, async (file, name) => {
-          try {
-            await (
-              require(file) as (
-                channel: ChannelWrapper,
-                connection: IAmqpConnection,
-                config: IAmqpConfig,
-                globalConfig: IConfig,
-              ) => Promise<void>
-            )(channel, connection, config, this.config);
-            this.log(config.name, name);
-          } catch (e) {}
-        });
-      },
-    );
-  }
-}

package/src/types/clickhouse.ts

@@ -1,62 +0,0 @@
-import { promises as fs } from 'fs';
-import { inject, Types } from '@biorate/inversion';
-import { Migration } from './migration';
-import {
-  IClickhouseConnector,
-  IClickhouseConnection,
-  IClickhouseConfig,
-} from '@biorate/clickhouse';
-/**
- * @description Clickhouse migration class
- */
-export class Clickhouse extends Migration {
-  @inject(Types.Clickhouse) protected connector: IClickhouseConnector;
-  /**
-   * @description Clickhouse process method realization
-   */
-  protected async process() {
-    await this.forEach<IClickhouseConfig, IClickhouseConnection>(
-      'Clickhouse',
-      async (config, connection, paths) => {
-        const tableName = this.config.get<string>('migrations.tableName', 'migrations');
-        const createQuery = `
-          CREATE TABLE IF NOT EXISTS {tableName:Identifier} (
-            name String
-          )
-          ENGINE = MergeTree()
-          PRIMARY KEY (name);
-        `;
-        await connection.command({
-          query: createQuery,
-          query_params: { tableName },
-          clickhouse_settings: {
-            wait_end_of_query: 1,
-          },
-        });
-        await this.forEachPath(paths, async (file, name) => {
-          const cursor = await connection.query({
-            query: `SELECT * FROM {tableName:Identifier} WHERE name = {name:String};`,
-            query_params: { name, tableName },
-            format: 'JSON',
-          });
-          const { data } = await cursor.json<{ name: string }>();
-          if (data.length) return;
-          await connection.command({
-            query: await fs.readFile(file, 'utf8'),
-            clickhouse_settings: {
-              wait_end_of_query: 1,
-            },
-          });
-          await connection.command({
-            query: `INSERT INTO {tableName:Identifier} (name) VALUES ({name:String})`,
-            query_params: { name, tableName },
-            clickhouse_settings: {
-              wait_end_of_query: 1,
-            },
-          });
-          this.log(config.name, name);
-        });
-      },
-    );
-  }
-}

package/src/types/index.ts

@@ -1,7 +0,0 @@
-export * from './sequelize';
-export * from './minio';
-export * from './mongodb';
-export * from './kafka';
-export * from './clickhouse';
-export * from './amqp';
-export * from './schema-registry';

package/src/types/kafka.ts

@@ -1,35 +0,0 @@
-import { inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-import {
-  IKafkaJSAdminConnector,
-  IKafkaJSAdminConfig,
-  IKafkaJSAdminConnection,
-} from '@biorate/kafkajs';
-import { Migration } from './migration';
-/**
- * @description Kafka migration class
- */
-export class Kafka extends Migration {
-  @inject(Types.Kafka) protected connector: IKafkaJSAdminConnector;
-  /**
-   * @description Kafka process method realization
-   */
-  protected async process() {
-    await this.forEach<IKafkaJSAdminConfig, IKafkaJSAdminConnection>(
-      'KafkaJSAdmin',
-      async (config, connection, paths) =>
-        await this.forEachPath(paths, async (file, name) => {
-          try {
-            await (
-              require(file) as (
-                connection: IKafkaJSAdminConnection,
-                config: IKafkaJSAdminConfig,
-                globalConfig: IConfig,
-              ) => Promise<void>
-            )(connection, config, this.config);
-            this.log(config.name, name);
-          } catch (e) {}
-        }),
-    );
-  }
-}

package/src/types/migration.ts

@@ -1,92 +0,0 @@
-import { promises as fs } from 'fs';
-import { path } from '@biorate/tools';
-import { init, injectable, inject, Types } from '@biorate/inversion';
-import { IConfig } from '@biorate/config';
-import { IConnector, IConnectorConfig } from '@biorate/connector';
-/**
- * @description Abstract migration class
- */
-@injectable()
-export abstract class Migration {
-  /**
-   * @description config property
-   */
-  @inject(Types.Config) protected config: IConfig;
-  /**
-   * @description connector property
-   */
-  protected abstract connector: IConnector<IConnectorConfig>;
-  /**
-   * @description Get migration type
-   */
-  protected get type() {
-    return this.constructor.name.toLowerCase();
-  }
-  /**
-   * @description Scan migration directory
-   */
-  protected async scan(...args: string[]) {
-    try {
-      return (await fs.readdir(this.path(...args))).map((item) =>
-        this.path(...args, item),
-      );
-    } catch {
-      return <string[]>[];
-    }
-  }
-  /**
-   * @description Create path to migrations directory
-   */
-  protected path(...args: string[]) {
-    return path.create(
-      process.cwd(),
-      this.config.get<string>('migrations.directory', 'migrations'),
-      this.type,
-      ...args,
-    );
-  }
-  /**
-   * @description Logging method
-   */
-  protected log(...args: string[]) {
-    console.info(this.type, ...args, 'up!');
-  }
-  /**
-   * @description Initialize method
-   */
-  @init() protected async initialize() {
-    console.info(this.constructor.name);
-    await this.process();
-  }
-  /**
-   * @description For each migration item
-   */
-  protected async forEach<T extends { name: string }, C>(
-    namespace: string,
-    callback: (config: T, connection: C, paths: string[]) => Promise<void>,
-  ) {
-    for (const config of this.config.get<T[]>(namespace, [])) {
-      const paths = await this.scan(config.name);
-      if (!paths.length) continue;
-      const connection = this.connector.connection(config.name);
-      if (!connection) {
-        console.info(`${namespace} connection [%s] not exists, skip...`, config.name);
-        continue;
-      }
-      await callback(config, connection, paths);
-    }
-  }
-  /**
-   * @description For each migration item
-   */
-  protected async forEachPath(
-    paths: string[],
-    callback: (file: string, name: string) => Promise<void>,
-  ) {
-    for (const p of paths) await callback(p, path.basename(p));
-  }
-  /**
-   * @description Abstract async process method
-   */
-  protected abstract process(): Promise<void>;
-}

package/src/types/minio.ts

@@ -1,39 +0,0 @@
-import { IMinioConnector, IMinioConfig, IMinioConnection } from '@biorate/minio';
-import { IConfig } from '@biorate/config';
-import { inject, Types } from '@biorate/inversion';
-import { Migration } from './migration';
-/**
- * @description Minio migration class
- */
-export class Minio extends Migration {
-  @inject(Types.Minio) protected connector: IMinioConnector;
-  /**
-   * @description Minio process method realization
-   */
-  protected async process() {
-    await this.forEach<IMinioConfig, IMinioConnection>(
-      'Minio',
-      async (config, connection, paths) =>
-        await this.forEachPath(paths, async (file, name) => {
-          const tableName = this.config.get<string>('migrations.tableName', 'migrations');
-          try {
-            await connection.makeBucket(tableName, tableName);
-          } catch {}
-
-          try {
-            await connection.getObject(tableName, name);
-          } catch (e) {
-            await (
-              require(file) as (
-                connection: IMinioConnection,
-                config: IMinioConfig,
-                globalConfig: IConfig,
-              ) => Promise<void>
-            )(connection, config, this.config);
-            await connection.putObject(tableName, name, Buffer.from('1'));
-            this.log(config.name, name);
-          }
-        }),
-    );
-  }
-}

package/src/types/mongodb.ts

@@ -1,36 +0,0 @@
-import { IMongoDBConfig, IMongoDBConnection, IMongoDBConnector } from '@biorate/mongodb';
-import { IConfig } from '@biorate/config';
-import { inject, Types } from '@biorate/inversion';
-import { Migration } from './migration';
-/**
- * @description Mongodb migration class
- */
-export class Mongodb extends Migration {
-  @inject(Types.Mongodb) protected connector: IMongoDBConnector;
-  /**
-   * @description Mongodb process method realization
-   */
-  protected async process() {
-    await this.forEach<IMongoDBConfig, IMongoDBConnection>(
-      'MongoDB',
-      async (config, connection, paths) =>
-        await this.forEachPath(paths, async (file, name) => {
-          try {
-            await (
-              require(file) as (
-                connection: IMongoDBConnection,
-                config: IMongoDBConfig,
-                globalConfig: IConfig,
-              ) => Promise<void>
-            )(connection, config, this.config);
-            await connection
-              .collection<{ _id: string }>(
-                this.config.get<string>('migrations.tableName', 'migrations'),
-              )
-              .insertOne({ _id: name });
-            this.log(config.name, name);
-          } catch (e) {}
-        }),
-    );
-  }
-}

package/src/types/schema-registry.ts

@@ -1,55 +0,0 @@
-import { kebabCase } from 'lodash';
-import { inject, Types } from '@biorate/inversion';
-import {
-  ISchemaRegistryConnector,
-  ISchemaRegistryConfig,
-  ISchemaRegistryConnection,
-  ICompatibilities,
-} from '@biorate/schema-registry';
-import { Migration } from './migration';
-import { SchemaRegistryWrongFileNameError } from '../errors';
-/**
- * @description Schema registry migration class
- */
-export class SchemaRegistry extends Migration {
-  @inject(Types.SchemaRegistry) protected connector: ISchemaRegistryConnector;
-  /**
-   * @description Get migration type
-   */
-  protected override get type() {
-    return kebabCase(this.constructor.name);
-  }
-  /**
-   * @description Schema registry process method realization
-   */
-  protected async process() {
-    await this.forEach<
-      ISchemaRegistryConfig & { compatibility?: ICompatibilities },
-      ISchemaRegistryConnection
-    >(
-      'SchemaRegistry',
-      async (config, connection, paths) =>
-        await this.forEachPath(paths, async (file, fullName) => {
-          const name = fullName.split('_')?.[1]?.replace('.json', '');
-          if (!name) throw new SchemaRegistryWrongFileNameError(fullName);
-          const schema = <Record<string, unknown>>require(file);
-          await connection.putConfig({
-            subject: name,
-            compatibility: config.compatibility ?? 'FORWARD',
-          });
-          try {
-            await connection.postSubjects({
-              subject: name,
-              schema,
-            });
-          } catch {
-            await connection.postSubjectsVersions({
-              subject: name,
-              schema,
-            });
-            this.log(config.name, fullName);
-          }
-        }),
-    );
-  }
-}

package/src/types/sequelize.ts

@@ -1,48 +0,0 @@
-import { promises as fs } from 'fs';
-import { inject, Types } from '@biorate/inversion';
-import { Migration } from './migration';
-import {
-  ISequelizeConnector,
-  ISequelizeConfig,
-  ISequelizeConnection,
-  DataType,
-  Transaction,
-} from '@biorate/sequelize';
-/**
- * @description Sequelize migration class
- */
-export class Sequelize extends Migration {
-  @inject(Types.Sequelize) protected connector: ISequelizeConnector;
-  /**
-   * @description Sequelize process method realization
-   */
-  protected async process() {
-    await this.forEach<ISequelizeConfig, ISequelizeConnection>(
-      'Sequelize',
-      async (config, connection, paths) => {
-        const model = connection.define(
-          this.config.get<string>('migrations.tableName', 'migrations'),
-          {
-            name: {
-              type: DataType.CHAR,
-              primaryKey: true,
-            },
-          },
-          { timestamps: false },
-        );
-        await model.sync({});
-        await this.forEachPath(
-          paths,
-          async (file, name) =>
-            await connection.transaction(async (transaction: Transaction) => {
-              const item = await model.findOne({ where: { name }, transaction });
-              if (item) return;
-              await connection.query(await fs.readFile(file, 'utf8'), { transaction });
-              await model.create({ name }, { transaction });
-              this.log(config.name, name);
-            }),
-        );
-      },
-    );
-  }
-}

package/tsconfig.build.json

@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["index.ts", "src/**/*"],
-  "exclude": ["node_modules", "dist", "tests", "**/*spec.ts"]
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "strict": true,
-    "strictPropertyInitialization": false
-  },
-  "include": ["index.ts", "src/**/*", "tests/**/*"],
-  "exclude": ["node_modules", "dist"]
-}