vona-module-a-ormdialect 5.0.19 → 5.0.20

package/dist/.metadata/index.d.ts

@@ -1,37 +1,54 @@
 /** databaseDialect: begin */
+export * from '../bean/databaseDialect.betterSqlite3.ts';
 export * from '../bean/databaseDialect.mysql.ts';
 export * from '../bean/databaseDialect.mysql3.ts';
 export * from '../bean/databaseDialect.pg.ts';
-import 'vona';
-declare module 'vona' {
+import type { IDatabaseDialectOptionsBetterSqlite3 } from '../bean/databaseDialect.betterSqlite3.ts';
+import type { IDatabaseDialectOptionsMysql } from '../bean/databaseDialect.mysql.ts';
+import type { IDatabaseDialectOptionsMysql3 } from '../bean/databaseDialect.mysql3.ts';
+import type { IDatabaseDialectOptionsPg } from '../bean/databaseDialect.pg.ts';
+import 'vona-module-a-orm';
+declare module 'vona-module-a-orm' {
     interface IDatabaseDialectRecord {
-        'a-ormdialect:mysql': never;
-        'a-ormdialect:mysql3': never;
-        'a-ormdialect:pg': never;
+        'a-ormdialect:betterSqlite3': IDatabaseDialectOptionsBetterSqlite3;
+        'a-ormdialect:mysql': IDatabaseDialectOptionsMysql;
+        'a-ormdialect:mysql3': IDatabaseDialectOptionsMysql3;
+        'a-ormdialect:pg': IDatabaseDialectOptionsPg;
     }
 }
 declare module 'vona-module-a-ormdialect' {
+    interface DatabaseDialectBetterSqlite3 {
+    }
+    interface DatabaseDialectBetterSqlite3 {
+        get $beanFullName(): 'a-ormdialect.databaseDialect.betterSqlite3';
+        get $onionName(): 'a-ormdialect:betterSqlite3';
+        get $onionOptions(): IDatabaseDialectOptionsBetterSqlite3;
+    }
     interface DatabaseDialectMysql {
     }
     interface DatabaseDialectMysql {
         get $beanFullName(): 'a-ormdialect.databaseDialect.mysql';
         get $onionName(): 'a-ormdialect:mysql';
+        get $onionOptions(): IDatabaseDialectOptionsMysql;
     }
     interface DatabaseDialectPg {
     }
     interface DatabaseDialectPg {
         get $beanFullName(): 'a-ormdialect.databaseDialect.pg';
         get $onionName(): 'a-ormdialect:pg';
+        get $onionOptions(): IDatabaseDialectOptionsPg;
     }
 }
 /** databaseDialect: end */
 /** databaseDialect: begin */
+import type { DatabaseDialectBetterSqlite3 } from '../bean/databaseDialect.betterSqlite3.ts';
 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.betterSqlite3': DatabaseDialectBetterSqlite3;
         'a-ormdialect.databaseDialect.mysql': DatabaseDialectMysql;
         'a-ormdialect.databaseDialect.mysql3': DatabaseDialectMysql3;
         'a-ormdialect.databaseDialect.pg': DatabaseDialectPg;

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

@@ -0,0 +1,18 @@
+import type { Knex } from 'knex';
+import type { TableIdentity } from 'table-identity';
+import type { ConfigDatabaseClient, IDatabaseDialectCapabilities, IDecoratorDatabaseDialectOptions, IFetchDatabasesResultItem, IFetchIndexesResultItem, TypeDatabaseDialectTableColumnsFn } from 'vona-module-a-orm';
+import { BeanDatabaseDialectBase } from 'vona-module-a-orm';
+export interface IDatabaseDialectOptionsBetterSqlite3 extends IDecoratorDatabaseDialectOptions {
+}
+export declare class DatabaseDialectBetterSqlite3 extends BeanDatabaseDialectBase {
+    protected _capabilities: IDatabaseDialectCapabilities;
+    getConfigBase(): ConfigDatabaseClient | undefined;
+    fetchDatabases(_schemaBuilder: Knex.SchemaBuilder, databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
+    createDatabase(_schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<string>;
+    dropDatabase(_schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    fetchIndexes(schemaBuilder: Knex.SchemaBuilder, tableName: string): Promise<IFetchIndexesResultItem[]>;
+    insert(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]>;
+    select(builder: Knex.QueryBuilder, datas: any[], fn: TypeDatabaseDialectTableColumnsFn): Promise<any[]>;
+    query(result: any): any;
+    private _getDbDir;
+}

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

@@ -1,11 +1,14 @@
 import type { Knex } from 'knex';
 import type { TableIdentity } from 'table-identity';
-import type { ConfigDatabaseClient, IFetchDatabasesResultItem, IFetchIndexesResultItem } from 'vona-module-a-orm';
+import type { ConfigDatabaseClient, IDatabaseDialectCapabilities, IDecoratorDatabaseDialectOptions, IFetchDatabasesResultItem, IFetchIndexesResultItem } from 'vona-module-a-orm';
 import { BeanDatabaseDialectBase } from 'vona-module-a-orm';
+export interface IDatabaseDialectOptionsMysql extends IDecoratorDatabaseDialectOptions {
+}
 export declare class DatabaseDialectMysql extends BeanDatabaseDialectBase {
+    protected _capabilities: IDatabaseDialectCapabilities;
     getConfigBase(): ConfigDatabaseClient | undefined;
     fetchDatabases(schemaBuilder: Knex.SchemaBuilder, databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
-    createDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    createDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<string>;
     dropDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
     fetchIndexes(schemaBuilder: Knex.SchemaBuilder, tableName: string): Promise<IFetchIndexesResultItem[]>;
     insert(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]>;

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

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

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

@@ -1,11 +1,14 @@
 import type { Knex } from 'knex';
 import type { TableIdentity } from 'table-identity';
-import type { ConfigDatabaseClient, IFetchDatabasesResultItem, IFetchIndexesResultItem } from 'vona-module-a-orm';
+import type { ConfigDatabaseClient, IDatabaseDialectCapabilities, IDecoratorDatabaseDialectOptions, IFetchDatabasesResultItem, IFetchIndexesResultItem } from 'vona-module-a-orm';
 import { BeanDatabaseDialectBase } from 'vona-module-a-orm';
+export interface IDatabaseDialectOptionsPg extends IDecoratorDatabaseDialectOptions {
+}
 export declare class DatabaseDialectPg extends BeanDatabaseDialectBase {
+    protected _capabilities: IDatabaseDialectCapabilities;
     getConfigBase(): ConfigDatabaseClient | undefined;
     fetchDatabases(schemaBuilder: Knex.SchemaBuilder, databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
-    createDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
+    createDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<string>;
     dropDatabase(schemaBuilder: Knex.SchemaBuilder, databaseName: string): Promise<void>;
     fetchIndexes(schemaBuilder: Knex.SchemaBuilder, tableName: string): Promise<IFetchIndexesResultItem[]>;
     insert(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]>;

package/dist/index.js

@@ -1,13 +1,94 @@
 import { BeanInfo, Virtual, BeanScopeBase } from 'vona';
-import { promisify } from 'node:util';
-import { isNil } from '@cabloy/utils';
+import path from 'node:path';
+import { ensureDir, remove } from 'fs-extra';
+import { globby } from 'globby';
 import { DatabaseDialect, BeanDatabaseDialectBase } from 'vona-module-a-orm';
+import { promisify } from 'node:util';
 import { Scope } from 'vona-module-a-bean';
 
+var _dec$4, _dec2$4, _class$4;
+let DatabaseDialectBetterSqlite3 = (_dec$4 = DatabaseDialect(), _dec2$4 = BeanInfo({
+  module: "a-ormdialect"
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class DatabaseDialectBetterSqlite3 extends BeanDatabaseDialectBase {
+  constructor(...args) {
+    super(...args);
+    this._capabilities = {
+      ilike: false,
+      level: false
+    };
+  }
+  getConfigBase() {
+    return {
+      pool: {
+        afterCreate(conn, done) {
+          sqlite3_afterCreate(conn).then(done).catch(done);
+        }
+      }
+    };
+  }
+  async fetchDatabases(_schemaBuilder, databasePrefix) {
+    const dbDir = this._getDbDir();
+    const files = await globby(`${databasePrefix}*.db`, {
+      cwd: dbDir,
+      onlyFiles: true
+    });
+    return files.map(item => {
+      return {
+        name: path.join(dbDir, item)
+      };
+    });
+  }
+  async createDatabase(_schemaBuilder, databaseName) {
+    const dbDir = this._getDbDir();
+    await ensureDir(dbDir);
+    return path.join(dbDir, `${databaseName}.db`);
+  }
+  async dropDatabase(_schemaBuilder, databaseName) {
+    await remove(databaseName);
+    for (const part of ['shm', 'wal', 'journal']) {
+      await remove(`${databaseName}-${part}`);
+    }
+  }
+  async fetchIndexes(schemaBuilder, tableName) {
+    let items = await schemaBuilder.raw(`PRAGMA index_list(${tableName})`);
+    items = items.map(item => {
+      return {
+        indexName: item.name
+      };
+    });
+    return items;
+  }
+  async insert(builder, datas) {
+    return await this.insertAsMysql(builder, datas);
+  }
+  async select(builder, datas, fn) {
+    return await this.selectAsSqlite3(builder, datas, fn);
+  }
+  query(result) {
+    return result;
+  }
+  _getDbDir() {
+    return path.join(this.app.projectPath, '.app/sqlite3');
+  }
+}) || _class$4) || _class$4);
+async function sqlite3_afterCreate(conn) {
+  const pragma = conn.pragma('journal_mode');
+  if (pragma[0]?.journal_mode?.toLocaleLowerCase() !== 'wal') {
+    conn.pragma('journal_mode = wal');
+  }
+}
+
 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 {
+  constructor(...args) {
+    super(...args);
+    this._capabilities = {
+      ilike: false,
+      level: true
+    };
+  }
   getConfigBase() {
     return {
       pool: {
@@ -30,6 +111,7 @@ let DatabaseDialectMysql = (_dec$3 = DatabaseDialect(), _dec2$3 = BeanInfo({
   }
   async createDatabase(schemaBuilder, databaseName) {
     await schemaBuilder.raw(`CREATE DATABASE \`${databaseName}\` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci`);
+    return databaseName;
   }
   async dropDatabase(schemaBuilder, databaseName) {
     await schemaBuilder.raw(`drop database \`${databaseName}\``);
@@ -45,21 +127,7 @@ let DatabaseDialectMysql = (_dec$3 = DatabaseDialect(), _dec2$3 = BeanInfo({
     return items;
   }
   async insert(builder, datas) {
-    if (datas.length === 0) return [];
-    if (isNil(datas[0].id)) {
-      const ids = [];
-      for (const data of datas) {
-        const builder2 = builder.clone();
-        builder2.insert(data);
-        const items = await builder2;
-        ids.push(items[0]);
-      }
-      return ids;
-    } else {
-      builder.insert(datas);
-      await builder;
-      return datas.map(item => item.id);
-    }
+    return await this.insertAsMysql(builder, datas);
   }
   query(result) {
     return result[0];
@@ -115,6 +183,13 @@ 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 {
+  constructor(...args) {
+    super(...args);
+    this._capabilities = {
+      ilike: true,
+      level: true
+    };
+  }
   getConfigBase() {
     return {
       connection: {
@@ -139,6 +214,7 @@ let DatabaseDialectPg = (_dec$1 = DatabaseDialect(), _dec2$1 = BeanInfo({
   }
   async createDatabase(schemaBuilder, databaseName) {
     await schemaBuilder.raw(`CREATE DATABASE "${databaseName}" encoding=UTF8`);
+    return databaseName;
   }
   async dropDatabase(schemaBuilder, databaseName) {
     await schemaBuilder.raw(`DROP DATABASE "${databaseName}"`);
@@ -154,16 +230,7 @@ let DatabaseDialectPg = (_dec$1 = DatabaseDialect(), _dec2$1 = BeanInfo({
     return items;
   }
   async insert(builder, datas) {
-    if (datas.length === 0) return [];
-    if (isNil(datas[0].id)) {
-      builder.insert(datas).returning('id');
-      const items = await builder;
-      return items.map(item => item.id);
-    } else {
-      builder.insert(datas);
-      await builder;
-      return datas.map(item => item.id);
-    }
+    return await this.insertAsPg(builder, datas);
   }
   query(result) {
     return result.rows;
@@ -201,4 +268,4 @@ let ScopeModuleAOrmdialect = (_dec = Scope(), _dec2 = BeanInfo({
 
 /** scope: end */
 
-export { DatabaseDialectMysql, DatabaseDialectMysql3, DatabaseDialectPg, ScopeModuleAOrmdialect };
+export { DatabaseDialectBetterSqlite3, DatabaseDialectMysql, DatabaseDialectMysql3, DatabaseDialectPg, ScopeModuleAOrmdialect };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "vona-module-a-ormdialect",
   "type": "module",
-  "version": "5.0.19",
+  "version": "5.0.20",
   "title": "a-ormdialect",
   "vonaModule": {
-    "dependencies": {}
+    "dependencies": {},
+    "globalDependencies": {
+      "better-sqlite3": true
+    }
   },
   "description": "",
   "author": "",
@@ -26,6 +29,8 @@
     "dist"
   ],
   "dependencies": {
+    "better-sqlite3": "^12.5.0",
+    "globby": "^16.0.0",
     "mysql2": "^3.15.0",
     "pg": "^8.16.3",
     "pg-types": "^4.1.0"