vona-module-a-ormdialect 5.0.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-present Vona
+
+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/dist/.metadata/index.d.ts

@@ -0,0 +1,57 @@
+/** databaseDialect: begin */
+export * from '../bean/databaseDialect.mysql.ts';
+export * from '../bean/databaseDialect.mysql3.ts';
+export * from '../bean/databaseDialect.pg.ts';
+import 'vona';
+declare module 'vona' {
+    interface IDatabaseDialectRecord {
+        'a-ormdialect:mysql': never;
+        'a-ormdialect:mysql3': never;
+        'a-ormdialect:pg': never;
+    }
+}
+declare module 'vona-module-a-ormdialect' {
+    interface DatabaseDialectMysql {
+    }
+    interface DatabaseDialectMysql {
+        get $beanFullName(): 'a-ormdialect.databaseDialect.mysql';
+        get $onionName(): 'a-ormdialect:mysql';
+    }
+    interface DatabaseDialectPg {
+    }
+    interface DatabaseDialectPg {
+        get $beanFullName(): 'a-ormdialect.databaseDialect.pg';
+        get $onionName(): 'a-ormdialect:pg';
+    }
+}
+/** databaseDialect: end */
+/** databaseDialect: begin */
+import type { DatabaseDialectMysql } from '../bean/databaseDialect.mysql.ts';
+import type { DatabaseDialectMysql3 } from '../bean/databaseDialect.mysql3.ts';
+import type { DatabaseDialectPg } from '../bean/databaseDialect.pg.ts';
+import 'vona';
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-ormdialect.databaseDialect.mysql': DatabaseDialectMysql;
+        'a-ormdialect.databaseDialect.mysql3': DatabaseDialectMysql3;
+        'a-ormdialect.databaseDialect.pg': DatabaseDialectPg;
+    }
+}
+/** databaseDialect: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+export declare class ScopeModuleAOrmdialect extends BeanScopeBase {
+}
+export interface ScopeModuleAOrmdialect {
+    util: BeanScopeUtil;
+}
+import 'vona';
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-ormdialect': ScopeModuleAOrmdialect;
+    }
+    interface IBeanScopeContainer {
+        ormdialect: ScopeModuleAOrmdialect;
+    }
+}
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-ormdialect";
+export { ScopeModuleAOrmdialect as ScopeModule } from './index.ts';

package/dist/bean/databaseDialect.mysql.d.ts

@@ -0,0 +1,13 @@
+import type { Knex } from 'knex';
+import type { ConfigDatabaseClient, IFetchDatabasesResultItem, IFetchIndexesResultItem, TableIdentity } from 'vona-module-a-orm';
+import { BeanDatabaseDialectBase } from 'vona-module-a-orm';
+export declare class DatabaseDialectMysql extends BeanDatabaseDialectBase {
+    getConfigBase(): ConfigDatabaseClient | undefined;
+    fetchDatabases(schemaBuilder: Knex.SchemaBuilder, databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
+    createDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    dropDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    fetchIndexes(schemaBuilder: Knex.SchemaBuilder, tableName: string): Promise<IFetchIndexesResultItem[]>;
+    insert(builder: Knex.QueryBuilder): Promise<TableIdentity[]>;
+    query(result: any): any;
+    viewDependents(builder: Knex.QueryBuilder, viewName: string): Promise<string[]>;
+}

package/dist/bean/databaseDialect.mysql3.d.ts

@@ -0,0 +1,5 @@
+import type { ConfigDatabaseClient } from 'vona-module-a-orm';
+import { DatabaseDialectMysql } from './databaseDialect.mysql.ts';
+export declare class DatabaseDialectMysql3 extends DatabaseDialectMysql {
+    getConfigBase(): ConfigDatabaseClient | undefined;
+}

package/dist/bean/databaseDialect.pg.d.ts

@@ -0,0 +1,13 @@
+import type { Knex } from 'knex';
+import type { ConfigDatabaseClient, IFetchDatabasesResultItem, IFetchIndexesResultItem, TableIdentity } from 'vona-module-a-orm';
+import { BeanDatabaseDialectBase } from 'vona-module-a-orm';
+export declare class DatabaseDialectPg extends BeanDatabaseDialectBase {
+    getConfigBase(): ConfigDatabaseClient | undefined;
+    fetchDatabases(schemaBuilder: Knex.SchemaBuilder, databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
+    createDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    dropDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    fetchIndexes(schemaBuilder: Knex.SchemaBuilder, tableName: string): Promise<IFetchIndexesResultItem[]>;
+    insert(builder: Knex.QueryBuilder): Promise<TableIdentity[]>;
+    query(result: any): any;
+    viewDependents(builder: Knex.QueryBuilder, viewName: string): Promise<string[]>;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './.metadata/index.ts';

package/dist/index.js

@@ -0,0 +1,183 @@
+import { BeanInfo, Virtual, BeanScopeBase } from 'vona';
+import { promisify } from 'node:util';
+import { DatabaseDialect, BeanDatabaseDialectBase } from 'vona-module-a-orm';
+import { Scope } from 'vona-module-a-bean';
+
+var _dec$3, _dec2$3, _class$3;
+let DatabaseDialectMysql = (_dec$3 = DatabaseDialect(), _dec2$3 = BeanInfo({
+  module: "a-ormdialect"
+}), _dec$3(_class$3 = _dec2$3(_class$3 = class DatabaseDialectMysql extends BeanDatabaseDialectBase {
+  getConfigBase() {
+    return {
+      pool: {
+        afterCreate(conn, done) {
+          mysql_afterCreate(conn).then(done).catch(done);
+        }
+      }
+    };
+  }
+  async fetchDatabases(schemaBuilder, databasePrefix) {
+    const res = await schemaBuilder.raw(`show databases like '${databasePrefix}%'`);
+    let dbs = res[0];
+    dbs = dbs.map(db => {
+      const name = db[Object.keys(db)[0]];
+      return {
+        name
+      };
+    });
+    return dbs;
+  }
+  async createDatabase(schemaBuilder, databaseName) {
+    await schemaBuilder.raw(`CREATE DATABASE \`${databaseName}\` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci`);
+  }
+  async dropDatabase(schemaBuilder, databaseName) {
+    await schemaBuilder.raw(`drop database \`${databaseName}\``);
+  }
+  async fetchIndexes(schemaBuilder, tableName) {
+    const res = await schemaBuilder.raw(`show index from ${tableName}`);
+    let items = res[0];
+    items = items.map(item => {
+      return {
+        indexName: item.Key_name
+      };
+    });
+    return items;
+  }
+  async insert(builder) {
+    const items = await builder;
+    return items;
+  }
+  query(result) {
+    return result[0];
+  }
+  async viewDependents(builder, viewName) {
+    const sqlViews = `
+      SELECT T.TABLE_SCHEMA ref_schema,
+        T.TABLE_NAME ref_name,
+        V.TABLE_NAME dep_name,
+        T.TABLE_TYPE type
+      FROM INFORMATION_SCHEMA.TABLES T 
+        INNER JOIN INFORMATION_SCHEMA.VIEWS V 
+          ON V.TABLE_SCHEMA = T.TABLE_SCHEMA
+          AND V.VIEW_DEFINITION LIKE CONCAT('%\`',T.TABLE_NAME,'\`%')
+      WHERE T.TABLE_SCHEMA = DATABASE()
+    `;
+    const items = await builder.distinct('dep_name').fromRaw(`(${sqlViews}) as viewDependents`).where({
+      ref_name: viewName
+    });
+    return items.map(item => item.dep_name);
+  }
+}) || _class$3) || _class$3);
+async function mysql_afterCreate(conn) {
+  await _executeQuery(conn, 'SET SESSION explicit_defaults_for_timestamp=ON');
+  await _executeQuery(conn, "SET SESSION sql_mode='NO_AUTO_VALUE_ON_ZERO'");
+}
+async function _executeQuery(conn, sql) {
+  const queryAsync = promisify(cb => conn.query(sql, cb));
+  return await queryAsync();
+}
+
+var _dec$2, _dec2$2, _dec3, _class$2;
+let DatabaseDialectMysql3 = (_dec$2 = DatabaseDialect(), _dec2$2 = Virtual(), _dec3 = BeanInfo({
+  module: "a-ormdialect"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = _dec3(_class$2 = class DatabaseDialectMysql3 extends DatabaseDialectMysql {
+  getConfigBase() {
+    return super.getConfigBase();
+    // const configBase = super.getConfigBase();
+    // return Object.assign({}, configBase, {
+    //   connection: {
+    //     // typeCast(field, next) {
+    //     //   if (field.type === 'JSON') {
+    //     //     return field.string('utf-8'); // utf8 https://github.com/sidorares/node-mysql2/pull/1662
+    //     //   }
+    //     //   return next();
+    //     // },
+    //   },
+    // });
+  }
+}) || _class$2) || _class$2) || _class$2);
+
+var _dec$1, _dec2$1, _class$1;
+let DatabaseDialectPg = (_dec$1 = DatabaseDialect(), _dec2$1 = BeanInfo({
+  module: "a-ormdialect"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class DatabaseDialectPg extends BeanDatabaseDialectBase {
+  getConfigBase() {
+    return {
+      connection: {
+        // types: {
+        //   getTypeParser: (oid: number, format: string): any => {
+        //     if (oid === 114) return pgTypes.getTypeParser(25, 'text');
+        //     return pgTypes.getTypeParser(oid, cast(format));
+        //   },
+        // },
+      }
+    };
+  }
+  async fetchDatabases(schemaBuilder, databasePrefix) {
+    const res = await schemaBuilder.raw(`select datname from pg_database where datname like '${databasePrefix}%'`);
+    let dbs = res.rows;
+    dbs = dbs.map(db => {
+      return {
+        name: db.datname
+      };
+    });
+    return dbs;
+  }
+  async createDatabase(schemaBuilder, databaseName) {
+    await schemaBuilder.raw(`CREATE DATABASE "${databaseName}" encoding=UTF8`);
+  }
+  async dropDatabase(schemaBuilder, databaseName) {
+    await schemaBuilder.raw(`DROP DATABASE "${databaseName}"`);
+  }
+  async fetchIndexes(schemaBuilder, tableName) {
+    const res = await schemaBuilder.raw(`select indexname,indexdef from pg_indexes where tablename='${tableName}'`);
+    let items = res.rows;
+    items = items.map(item => {
+      return {
+        indexName: item.indexname
+      };
+    });
+    return items;
+  }
+  async insert(builder) {
+    builder.returning('id');
+    const items = await builder;
+    return items.map(item => item.id);
+  }
+  query(result) {
+    return result.rows;
+  }
+  async viewDependents(builder, viewName) {
+    const sqlViews = `
+      select
+          ref_nsp.nspname ref_schema, ref_cl.relname ref_name,
+          rwr_cl.relkind dep_type,
+          rwr_nsp.nspname dep_schema,
+          rwr_cl.relname dep_name
+        from pg_depend dep
+          join pg_class ref_cl on dep.refobjid = ref_cl.oid
+          join pg_namespace ref_nsp on ref_cl.relnamespace = ref_nsp.oid
+          join pg_rewrite rwr on dep.objid = rwr.oid
+          join pg_class rwr_cl on rwr.ev_class = rwr_cl.oid
+          join pg_namespace rwr_nsp on rwr_cl.relnamespace = rwr_nsp.oid
+        where
+          dep.deptype = 'n'
+          and dep.classid = 'pg_rewrite'::regclass
+    `;
+    let items = await builder.distinct('dep_name').fromRaw(`(${sqlViews}) as depend_view`).where({
+      ref_name: viewName
+    });
+    items = items.map(item => item.dep_name);
+    items = items.filter(item => item.toLowerCase() !== viewName.toLowerCase());
+    return items;
+  }
+}) || _class$1) || _class$1);
+
+var _dec, _dec2, _class;
+let ScopeModuleAOrmdialect = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-ormdialect"
+}), _dec(_class = _dec2(_class = class ScopeModuleAOrmdialect extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+export { DatabaseDialectMysql, DatabaseDialectMysql3, DatabaseDialectPg, ScopeModuleAOrmdialect };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "vona-module-a-ormdialect",
+  "type": "module",
+  "version": "5.0.13",
+  "title": "a-ormdialect",
+  "vonaModule": {
+    "dependencies": {}
+  },
+  "description": "",
+  "author": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "static"
+  ],
+  "dependencies": {
+    "mysql2": "^3.12.0",
+    "pg": "^8.13.3",
+    "pg-types": "^4.0.2"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
+  }
+}