imodel-pg 0.14.0 → 0.15.0

package/index.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.14.0
+ * imodel v0.15.0
  * (c) 2019-2026 undefined
  * @license undefined
  */

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.14.0
+ * imodel v0.15.0
  * (c) 2019-2026 undefined
  * @license undefined
  */
@@ -340,14 +340,14 @@ function renameColumn(table, column, newName) {
  */
 function addIndex(table, name, columns, {
   unique,
-  include
+  includes
 } = {}) {
   const create = unique ? Sql`CREATE UNIQUE INDEX` : Sql`CREATE INDEX`;
   const id = Sql.Id(`${table}#${name}`);
   const allColumns = Sql`, `.glue(...columns.map(v => Sql.Field(v)));
   const fieldSqls = Sql`ON ${Sql.Table(table)}(${allColumns})`;
-  const includes = include?.length ? Sql`INCLUDE (${Sql`, `.glue(...include.map(v => Sql.Field(v)))})` : undefined;
-  return Sql(create, id, fieldSqls, includes);
+  const includesSql = includes?.length ? Sql`INCLUDE (${Sql`, `.glue(...includes.map(v => Sql.Field(v)))})` : undefined;
+  return Sql(create, id, fieldSqls, includesSql);
 }
 
 /**
@@ -950,25 +950,29 @@ FROM (values${Sql`,`.glue(list.map(data => Sql`(${Sql`,`.glue(dataFieldType.map(
 WHERE ${Sql`AND`.glue([pKeys.map(f => Sql`${main.field(f)}=${tmp.field(f)}`), getWhere2(env, where)].flat().filter(Boolean))}${returnSql}`;
 }
 
+const defaultSchema = Sql`(SELECT (current_schemas(false))[1])`;
+
 /** @import { Environment, IConnection } from 'imodel' */
 /** @import { PgEnvTrans } from '../index.mjs' */
 /** @import { DBIndex, DBTable, DBColumn } from 'imodel' */
 const tableType = 'BASE TABLE';
+// eslint-disable-next-line max-len
+const textRegex = /^'(?<text>(?:[^']|'')+)'(?:::(?<type>character varying|text|jsonb?))?$/;
 /**
  *
  * @param {Environment<PgEnvTrans>} env
- * @param {string} schema
  * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
  * @param {string[]} tables
- * @returns {Promise<(DBColumn & {table: string; name: string})[]>}
+ * @param {string?} [schema]
+ * @returns {Promise<(DBColumn & {table: string; name: string; defaultExp: string?})[]>}
  */
-async function loadFields(env, schema, query, tables) {
+async function loadFields(env, query, tables, schema) {
   const sql = Sql`
 SELECT *
 FROM 
 	information_schema.columns t
 WHERE 
-	table_schema = ${schema} 
+	table_schema = ${defaultSchema}
 	AND
 	t.table_name IN (${Sql`,`.glue(tables.map(t => Sql`${t}`))})
 `;
@@ -984,7 +988,7 @@ WHERE
     let scale = 0;
     const nullable = column.is_nullable === 'YES';
     /** @type {any} */
-    let defaultValue = column.column_default;
+    let defaultExp = column.column_default;
     switch (type) {
       case 'int2':
         type = 'i16';
@@ -1057,26 +1061,58 @@ WHERE
       case 'json':
         type = 'json';
     }
-    if (defaultValue === 'CURRENT_TIMESTAMP' || defaultValue === 'now()') {
+    let defaultValue;
+    const regexResult = textRegex.exec(defaultExp)?.groups;
+    if (regexResult) {
+      const {
+        text,
+        type
+      } = regexResult;
+      if (typeof text === 'string') {
+        const str = text.replaceAll("''", '');
+        switch (type) {
+          case 'json':
+          case 'jsonb':
+            try {
+              defaultValue = JSON.parse(str);
+            } catch {}
+            break;
+          default:
+            defaultValue = str;
+            break;
+        }
+        defaultExp = null;
+      }
+    } else if (defaultExp === 'CURRENT_TIMESTAMP' || defaultExp === 'now()') {
       defaultValue = env.values.now;
-    } else if (defaultValue === 'gen_random_uuid()') {
+      defaultExp = null;
+    } else if (defaultExp === 'gen_random_uuid()') {
       defaultValue = env.values.uuid;
-    } else if (defaultValue === 'false') {
+      defaultExp = null;
+    } else if (defaultExp === 'false') {
       defaultValue = false;
-    } else if (defaultValue === 'true') {
+      defaultExp = null;
+    } else if (defaultExp === 'true') {
       defaultValue = true;
-    } else if (defaultValue === `''::character varying`) {
+      defaultExp = null;
+    } else if (defaultExp === `''::character varying`) {
       defaultValue = '';
-    } else if (defaultValue === `''::text`) {
+      defaultExp = null;
+    } else if (defaultExp === `''::text`) {
       defaultValue = '';
-    } else if (defaultValue === `'[]'::json`) {
+      defaultExp = null;
+    } else if (defaultExp === `'[]'::json`) {
       defaultValue = [];
-    } else if (defaultValue === `'{}'::json`) {
+      defaultExp = null;
+    } else if (defaultExp === `'{}'::json`) {
       defaultValue = {};
-    } else if (/^ARRAY\[\]::[a-z \d]+\[\]$/.test(defaultValue)) {
+      defaultExp = null;
+    } else if (/^ARRAY\[\]::[a-z \d]+\[\]$/.test(defaultExp)) {
       defaultValue = [];
-    } else if (/^\d+(.\d+)?(?:::[a-z \d]+)?$/.test(defaultValue)) {
-      defaultValue = Number(defaultValue);
+      defaultExp = null;
+    } else if (/^\d+(.\d+)?(?:::[a-z \d]+)?$/.test(defaultExp)) {
+      defaultValue = Number(defaultExp);
+      defaultExp = null;
     }
     return {
       table: column.table_name,
@@ -1086,6 +1122,7 @@ WHERE
       scale,
       nullable,
       default: defaultValue,
+      defaultExp,
       array
     };
   });
@@ -1094,16 +1131,16 @@ WHERE
  *
  * @param {Environment<PgEnvTrans>} env
  * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
- * @param {(DBColumn & {table: string; name: string})[]} fields
+ * @param {(DBColumn & {table: string; name: string; defaultExp: string?})[]} fields
  * @returns {Promise<(DBColumn & {table: string; name: string})[]>}
  */
 async function loadDefault(env, query, fields) {
-  const data = fields.filter(v => v.default && typeof v.default === 'string');
+  const data = fields.filter(v => v.defaultExp);
   if (!data.length) {
     return fields;
   }
   const sql = Sql`
-SELECT ${Sql`,`.glue(data.map((v, k) => Sql(`${v.default} as a${k}`)))}
+SELECT ${Sql`,`.glue(data.map((v, k) => Sql(`${v.defaultExp} as a${k}`)))}
 `;
   const [values = {}] = await query(env, sql);
   for (const [index, column] of data.entries()) {
@@ -1114,12 +1151,12 @@ SELECT ${Sql`,`.glue(data.map((v, k) => Sql(`${v.default} as a${k}`)))}
 /**
  *
  * @param {Environment<PgEnvTrans>} env
- * @param {string} schema
  * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
  * @param {string[]} tables
+ * @param {string?} [schema]
  * @returns {Promise<[(DBIndex & {table: string})[], ({fields: string[], name: string, table: string})[]]>}
  */
-async function loadIndex(env, schema, query, tables) {
+async function loadIndex(env, query, tables, schema) {
   const sql = Sql`
 SELECT 
 	t.relname AS table,
@@ -1140,6 +1177,10 @@ JOIN
 JOIN 
 	pg_class i ON ix.indexrelid = i.oid
 WHERE 
+	t.relnamespace IN (
+		SELECT oid FROM pg_namespace WHERE nspname = ${defaultSchema}
+	)
+	AND
 	t.relname IN (${Sql`,`.glue(tables.map(t => Sql`${t}`))})
 	AND
 	t.relkind = 'r'; -- 只匹配普通表
@@ -1170,16 +1211,16 @@ WHERE
 /**
  *
  * @param {Environment<PgEnvTrans>} env
- * @param {string} schema
  * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
  * @param {string[]} tables
+ * @param {string?} [schema]
  * @returns {Promise<string[]>}
  */
-async function loadBaseTables(env, schema, query, tables) {
+async function loadBaseTables(env, query, tables, schema) {
   const sql = Sql`SELECT *
 		FROM information_schema.tables
 		WHERE
-			table_schema = ${schema} 
+			table_schema = ${defaultSchema}
 			AND
 			table_type = ${tableType}
 			AND
@@ -1190,13 +1231,13 @@ async function loadBaseTables(env, schema, query, tables) {
 /**
  *
  * @param {Environment<PgEnvTrans>} env
- * @param {string} schema
  * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
  * @param {string[]} tables
+ * @param {string?} [schema]
  * @returns {Promise<DBTable[]>}
  */
-async function loadTables(env, schema, query, tables) {
-  const [baseTables, allFields, [allIndexes, allPrimary]] = await Promise.all([loadBaseTables(env, schema, query, tables), loadFields(env, schema, query, tables).then(fields => loadDefault(env, query, fields)), loadIndex(env, schema, query, tables)]);
+async function loadTables(env, query, tables, schema) {
+  const [baseTables, allFields, [allIndexes, allPrimary]] = await Promise.all([loadBaseTables(env, query, tables), loadFields(env, query, tables).then(fields => loadDefault(env, query, fields)), loadIndex(env, query, tables)]);
   const allTables = new Set(baseTables);
   const fieldsGroup = Object.groupBy(allFields, f => f.table);
   const indexesGroup = Object.groupBy(allIndexes, f => f.table);
@@ -1591,14 +1632,13 @@ ADD PRIMARY KEY (${Sql`,`.glue(primary.map(f => Sql.Field(f)))})
 /**
  *
  * @param {Environment<PgEnvTrans>} env
- * @param {string} schema
  * @param {<T extends pg.QueryResultRow>(env: Environment<PgEnvTrans>, sql: Sql) => Promise<T[]>} query
  * @param {DBTable[]} tables
- * @param {boolean} [del]
+ * @param {string} [schema]
  */
-async function syncTables(env, schema, query, tables, del) {
+async function syncTables(env, query, tables, schema) {
   const tableNames = tables.map(v => v.table);
-  const dbTables = await loadTables(env, schema, query, tableNames);
+  const dbTables = await loadTables(env, query, tableNames);
   const tableMap = new Map(dbTables.map(v => [v.table, v]));
   for (const table of tables) {
     const old = tableMap.get(table.table);
@@ -1691,7 +1731,6 @@ function toPoolConnection(pool) {
  */
 function index (pool, version) {
   const connect = toPoolConnection(pool);
-  const schema = 'public';
   const dbVersion = typeof version === 'function' ? version : createVersion(connect);
   /**
    * @template {pg.QueryResultRow} T
@@ -1762,7 +1801,8 @@ function index (pool, version) {
     async type(env, table) {
       const sql = Sql`SELECT table_type as type
 			FROM information_schema.tables
-			WHERE table_schema = ${schema} AND table_name = ${table} LIMIT 1`;
+			WHERE table_schema = (SELECT (current_schemas(false))[1])
+			AND table_name = ${table} LIMIT 1`;
       /** @type {pg.QueryResult<{ type: string; }>} */
       const {
         rows: [row]
@@ -1851,10 +1891,10 @@ function index (pool, version) {
       return exec(env, renameTable(table, newName));
     },
     loadTables(env, tables) {
-      return loadTables(env, schema, query, tables);
+      return loadTables(env, query, tables);
     },
     syncTables(env, tables) {
-      return syncTables(env, schema, query, tables);
+      return syncTables(env, query, tables);
     },
     async transaction(env, fn) {
       if (env?.transaction?.client) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imodel-pg",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "dependencies": {
     "pg": "^8.13.3",
     "tagged-sql": "^0.9.0"