orange-orm 4.2.0 → 4.3.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/package.json +3 -2
  2. package/src/mssql/newDatabase.js +2 -2
  3. package/src/mssql/newTransaction.js +52 -28
  4. package/src/mySql/newDatabase.js +2 -2
  5. package/src/mySql/newTransaction.js +44 -21
  6. package/src/oracle/newDatabase.js +2 -2
  7. package/src/oracle/newTransaction.js +47 -21
  8. package/src/pg/newDatabase.js +2 -2
  9. package/src/pg/newTransaction.js +44 -22
  10. package/src/sap/newDatabase.js +2 -2
  11. package/src/sap/newTransaction.js +52 -28
  12. package/src/sqlite/newDatabase.js +2 -2
  13. package/src/sqlite/newTransaction.js +41 -18
  14. package/src/tedious/newDatabase.js +2 -2
  15. package/src/tedious/newTransaction.js +53 -30
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "orange-orm",
3
- "version": "4.2.0",
3
+ "version": "4.3.0-beta.1",
4
4
  "main": "./src/index.js",
5
5
  "browser": "./src/client/index.mjs",
6
6
  "bin": {
@@ -47,7 +47,8 @@
47
47
  "build": "rollup -c ./src/client/rollup.config.js && npm run concat",
48
48
  "lint": "eslint ./",
49
49
  "fix": "eslint ./ --fix",
50
- "owasp": "owasp-dependency-check --project \"MY_PROJECT\" --scan \"package-lock.json\" --exclude \"dependency-check-bin\" --out \"owasp\" --format HTML"
50
+ "owasp": "owasp-dependency-check --project \"MY_PROJECT\" --scan \"package-lock.json\" --exclude \"dependency-check-bin\" --out \"owasp\" --format HTML",
51
+ "beta": "publish --tag beta"
51
52
  },
52
53
  "dependencies": {
53
54
  "@lroal/on-change": "^4.0.2",
package/src/mssql/newDatabase.js CHANGED
@@ -43,7 +43,7 @@ function newDatabase(connectionString, poolOptions) {
43
43
 
44
44
  async function runInTransaction() {
45
45
  let result;
46
- let transaction = newTransaction(domain, pool);
46
+ let transaction = newTransaction(domain, pool, options);
47
47
  await new Promise(transaction)
48
48
  .then(begin)
49
49
  .then(fn)
@@ -59,7 +59,7 @@ function newDatabase(connectionString, poolOptions) {
59
59
 
60
60
  function run() {
61
61
  let p;
62
- let transaction = newTransaction(domain, pool);
62
+ let transaction = newTransaction(domain, pool, options);
63
63
  if (useHook())
64
64
  p = new Promise(transaction);
65
65
  else
package/src/mssql/newTransaction.js CHANGED
@@ -8,12 +8,63 @@ const formatDateOut = require('../tedious/formatDateOut');
8
8
  const insertSql = require('../tedious/insertSql');
9
9
  const insert = require('../tedious/insert');
10
10
 
11
- function newResolveTransaction(domain, pool) {
11
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
12
12
  var rdb = {poolFactory: pool};
13
13
  if (!pool.connect) {
14
14
  pool = pool();
15
15
  rdb.pool = pool;
16
16
  }
17
+ rdb.engine = 'mssqlNative';
18
+ rdb.encodeBoolean = encodeBoolean;
19
+ rdb.decodeJSON = decodeJSON;
20
+ rdb.encodeJSON = JSON.stringify;
21
+ rdb.formatDateOut = formatDateOut;
22
+ rdb.deleteFromSql = deleteFromSql;
23
+ rdb.selectForUpdateSql = selectForUpdateSql;
24
+ rdb.outputInsertedSql = outputInsertedSql;
25
+ rdb.insertSql = insertSql;
26
+ rdb.insert = insert;
27
+ rdb.lastInsertedIsSeparate = false;
28
+ rdb.multipleStatements = true;
29
+ rdb.begin = 'BEGIN TRANSACTION';
30
+ rdb.limit = (span) => {
31
+ if (span.offset)
32
+ return '';
33
+ else if (span.limit || span.limit === 0)
34
+ return 'TOP ' + span.limit;
35
+ else
36
+ return '';
37
+ };
38
+ rdb.limitAndOffset = limitAndOffset;
39
+ rdb.accept = function(caller) {
40
+ caller.visitSqlite();
41
+ };
42
+ rdb.aggregateCount = 0;
43
+ rdb.quote = (name) => `[${name}]`;
44
+
45
+ if (readonly) {
46
+ rdb.dbClient = {
47
+ executeQuery: function(query, callback) {
48
+ pool.connect((err, client, done) => {
49
+ if (err) {
50
+ return callback(err);
51
+ }
52
+ try {
53
+ client.setUseUTC(false);
54
+ wrapQuery(client)(query, (err, res) => {
55
+ done();
56
+ callback(err, res);
57
+ });
58
+ } catch (e) {
59
+ done();
60
+ callback(e);
61
+ }
62
+ });
63
+ }
64
+ };
65
+ domain.rdb = rdb;
66
+ return (onSuccess) => onSuccess();
67
+ }
17
68
 
18
69
  return function(onSuccess, onError) {
19
70
  pool.connect(onConnected);
@@ -26,35 +77,8 @@ function newResolveTransaction(domain, pool) {
26
77
  }
27
78
  client.setUseUTC(false);
28
79
  client.executeQuery = wrapQuery(client);
29
- rdb.engine = 'mssqlNative';
30
80
  rdb.dbClient = client;
31
81
  rdb.dbClientDone = done;
32
- rdb.encodeBoolean = encodeBoolean;
33
- rdb.decodeJSON = decodeJSON;
34
- rdb.encodeJSON = JSON.stringify;
35
- rdb.formatDateOut = formatDateOut;
36
- rdb.deleteFromSql = deleteFromSql;
37
- rdb.selectForUpdateSql = selectForUpdateSql;
38
- rdb.outputInsertedSql = outputInsertedSql;
39
- rdb.insertSql = insertSql;
40
- rdb.insert = insert;
41
- rdb.lastInsertedIsSeparate = false;
42
- rdb.multipleStatements = true;
43
- rdb.begin = 'BEGIN TRANSACTION';
44
- rdb.limit = (span) => {
45
- if (span.offset)
46
- return '';
47
- else if (span.limit || span.limit === 0)
48
- return 'TOP ' + span.limit;
49
- else
50
- return '';
51
- };
52
- rdb.limitAndOffset = limitAndOffset;
53
- rdb.accept = function(caller) {
54
- caller.visitSqlite();
55
- };
56
- rdb.aggregateCount = 0;
57
- rdb.quote = (name) => `[${name}]`;
58
82
  domain.rdb = rdb;
59
83
  onSuccess();
60
84
  } catch (e) {
package/src/mySql/newDatabase.js CHANGED
@@ -42,7 +42,7 @@ function newDatabase(connectionString, poolOptions) {
42
42
 
43
43
  async function runInTransaction() {
44
44
  let result;
45
- let transaction = newTransaction(domain, pool);
45
+ let transaction = newTransaction(domain, pool, options);
46
46
  await new Promise(transaction)
47
47
  .then(begin)
48
48
  .then(fn)
@@ -58,7 +58,7 @@ function newDatabase(connectionString, poolOptions) {
58
58
 
59
59
  function run() {
60
60
  let p;
61
- let transaction = newTransaction(domain, pool);
61
+ let transaction = newTransaction(domain, pool, options);
62
62
  if (useHook())
63
63
  p = new Promise(transaction);
64
64
  else
package/src/mySql/newTransaction.js CHANGED
@@ -7,42 +7,65 @@ const limitAndOffset = require('./limitAndOffset');
7
7
  const insertSql = require('./insertSql');
8
8
  const insert = require('./insert');
9
9
 
10
- function newResolveTransaction(domain, pool) {
10
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
11
11
  var rdb = {poolFactory: pool};
12
12
  if (!pool.connect) {
13
13
  pool = pool();
14
14
  rdb.pool = pool;
15
15
  }
16
+ rdb.engine = 'mysql';
17
+ rdb.encodeBoolean = encodeBoolean;
18
+ rdb.encodeJSON = JSON.stringify;
19
+ rdb.deleteFromSql = deleteFromSql;
20
+ rdb.selectForUpdateSql = selectForUpdateSql;
21
+ rdb.lastInsertedIsSeparate = true;
22
+ rdb.lastInsertedSql = lastInsertedSql;
23
+ rdb.insertSql = insertSql;
24
+ rdb.insert = insert;
25
+ rdb.multipleStatements = false;
26
+ rdb.limitAndOffset = limitAndOffset;
27
+ rdb.accept = function(caller) {
28
+ caller.visitMySql();
29
+ };
30
+ rdb.aggregateCount = 0;
31
+ rdb.quote = (name) => `\`${name}\``;
32
+
33
+
34
+ if (readonly) {
35
+ rdb.dbClient = {
36
+ executeQuery: function(query, callback) {
37
+ pool.connect((err, client, done) => {
38
+ if (err) {
39
+ return callback(err);
40
+ }
41
+ try {
42
+ wrapQuery(client)(query, (err, res) => {
43
+ done();
44
+ callback(err, res);
45
+ });
46
+ } catch (e) {
47
+ done();
48
+ callback(e);
49
+ }
50
+ });
51
+ }
52
+ };
53
+ domain.rdb = rdb;
54
+ return (onSuccess) => onSuccess();
55
+ }
16
56
 
17
57
  return function(onSuccess, onError) {
18
58
  pool.connect(onConnected);
19
59
 
20
- function onConnected(err, connection, done) {
60
+ function onConnected(err, client, done) {
21
61
  try {
22
62
  if (err) {
23
63
  onError(err);
24
64
  return;
25
65
  }
26
- connection.executeQuery = wrapQuery(connection);
27
- // connection.streamQuery = wrapQueryStream(connection);
28
- rdb.engine = 'mysql';
29
- rdb.dbClient = connection;
66
+ client.executeQuery = wrapQuery(client);
67
+ rdb.dbClient = client;
30
68
  rdb.dbClientDone = done;
31
- rdb.encodeBoolean = encodeBoolean;
32
- rdb.encodeJSON = JSON.stringify;
33
- rdb.deleteFromSql = deleteFromSql;
34
- rdb.selectForUpdateSql = selectForUpdateSql;
35
- rdb.lastInsertedIsSeparate = true;
36
- rdb.lastInsertedSql = lastInsertedSql;
37
- rdb.insertSql = insertSql;
38
- rdb.insert = insert;
39
- rdb.multipleStatements = false;
40
- rdb.limitAndOffset = limitAndOffset;
41
- rdb.accept = function(caller) {
42
- caller.visitMySql();
43
- };
44
- rdb.aggregateCount = 0;
45
- rdb.quote = (name) => `\`${name}\``;
46
69
  domain.rdb = rdb;
47
70
  onSuccess();
48
71
  } catch (e) {
package/src/oracle/newDatabase.js CHANGED
@@ -47,7 +47,7 @@ function newDatabase(connectionString, poolOptions) {
47
47
 
48
48
  async function runInTransaction() {
49
49
  let result;
50
- let transaction = newTransaction(domain, pool);
50
+ let transaction = newTransaction(domain, pool, options);
51
51
  await new Promise(transaction)
52
52
  .then(begin)
53
53
  .then(fn)
@@ -59,7 +59,7 @@ function newDatabase(connectionString, poolOptions) {
59
59
 
60
60
  function run() {
61
61
  let p;
62
- let transaction = newTransaction(domain, pool);
62
+ let transaction = newTransaction(domain, pool, options);
63
63
  if (useHook())
64
64
  p = new Promise(transaction);
65
65
  else
package/src/oracle/newTransaction.js CHANGED
@@ -9,13 +9,58 @@ const insert = require('./insert');
9
9
  const formatDateOut = require('./formatDateOut');
10
10
  const formatDateIn = require('./formatDateIn');
11
11
 
12
- function newResolveTransaction(domain, pool) {
12
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
13
13
  var rdb = {poolFactory: pool};
14
14
  if (!pool.connect) {
15
15
  pool = pool();
16
16
  rdb.pool = pool;
17
17
  }
18
18
 
19
+ rdb.begin = 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED';
20
+ rdb.engine = 'oracle';
21
+ rdb.encodeBoolean = encodeBoolean;
22
+ rdb.decodeJSON = decodeJSON;
23
+ rdb.encodeJSON = JSON.stringify;
24
+ rdb.formatDateOut = formatDateOut;
25
+ rdb.formatDateIn = formatDateIn;
26
+ rdb.deleteFromSql = deleteFromSql;
27
+ rdb.selectForUpdateSql = selectForUpdateSql;
28
+ rdb.lastInsertedSql = lastInsertedSql;
29
+ rdb.insertSql = insertSql;
30
+ rdb.insert = insert;
31
+ rdb.lastInsertedIsSeparate = true;
32
+ rdb.multipleStatements = false;
33
+ rdb.limitAndOffset = limitAndOffset;
34
+ rdb.accept = function(caller) {
35
+ caller.visitSqlite();
36
+ };
37
+ rdb.aggregateCount = 0;
38
+ rdb.quote = (name) => `"${name}"`;
39
+
40
+ if (readonly) {
41
+ rdb.dbClient = {
42
+ executeQuery: function(query, callback) {
43
+ pool.connect((err, client, done) => {
44
+ if (err) {
45
+ return callback(err);
46
+ }
47
+ try {
48
+ wrapQuery(client)(query, (err, res) => {
49
+ done();
50
+ callback(err, res);
51
+ });
52
+ } catch (e) {
53
+ done();
54
+ callback(e);
55
+ }
56
+ });
57
+ }
58
+ };
59
+ domain.rdb = rdb;
60
+ return (onSuccess) => onSuccess();
61
+ }
62
+
63
+
19
64
  return function(onSuccess, onError) {
20
65
  pool.connect(onConnected);
21
66
 
@@ -26,29 +71,10 @@ function newResolveTransaction(domain, pool) {
26
71
  return;
27
72
  }
28
73
  client.executeQuery = wrapQuery(client);
29
- rdb.begin = 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED';
30
- rdb.engine = 'oracle';
31
74
  rdb.dbClient = client;
32
75
  rdb.dbClientDone = done;
33
- rdb.encodeBoolean = encodeBoolean;
34
- rdb.decodeJSON = decodeJSON;
35
- rdb.encodeJSON = JSON.stringify;
36
- rdb.formatDateOut = formatDateOut;
37
- rdb.formatDateIn = formatDateIn;
38
- rdb.deleteFromSql = deleteFromSql;
39
- rdb.selectForUpdateSql = selectForUpdateSql;
40
- rdb.lastInsertedSql = lastInsertedSql;
41
- rdb.insertSql = insertSql;
42
- rdb.insert = insert;
43
- rdb.lastInsertedIsSeparate = true;
44
- rdb.multipleStatements = false;
45
- rdb.limitAndOffset = limitAndOffset;
46
- rdb.accept = function(caller) {
47
- caller.visitSqlite();
48
- };
49
- rdb.aggregateCount = 0;
50
- rdb.quote = (name) => `"${name}"`;
51
76
  domain.rdb = rdb;
77
+
52
78
  onSuccess();
53
79
  } catch (e) {
54
80
  onError(e);
package/src/pg/newDatabase.js CHANGED
@@ -52,7 +52,7 @@ function newDatabase(connectionString, poolOptions) {
52
52
 
53
53
  async function runInTransaction() {
54
54
  let result;
55
- let transaction = newTransaction(domain, pool);
55
+ let transaction = newTransaction(domain, pool, options);
56
56
  await new Promise(transaction)
57
57
  .then(begin)
58
58
  .then(negotiateSchema)
@@ -69,7 +69,7 @@ function newDatabase(connectionString, poolOptions) {
69
69
 
70
70
  function run() {
71
71
  let p;
72
- let transaction = newTransaction(domain, pool);
72
+ let transaction = newTransaction(domain, pool, options);
73
73
  if (useHook())
74
74
  p = new Promise(transaction);
75
75
  else
package/src/pg/newTransaction.js CHANGED
@@ -1,5 +1,4 @@
1
1
  var wrapQuery = require('./wrapQuery');
2
- var wrapQueryStream = require('./wrapQueryStream');
3
2
  var encodeDate = require('./encodeDate');
4
3
  var encodeBoolean = require('./encodeBoolean');
5
4
  var deleteFromSql = require('./deleteFromSql');
@@ -10,13 +9,54 @@ var encodeJSON = require('./encodeJSON');
10
9
  var insertSql = require('./insertSql');
11
10
  var insert = require('./insert');
12
11
 
13
- function newResolveTransaction(domain, pool) {
14
- var rdb = {poolFactory: pool};
12
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
13
+ var rdb = { poolFactory: pool };
15
14
  if (!pool.connect) {
16
15
  pool = pool();
17
16
  rdb.pool = pool;
18
17
  }
19
18
 
19
+ rdb.engine = 'pg';
20
+ rdb.encodeBoolean = encodeBoolean;
21
+ rdb.encodeDate = encodeDate;
22
+ rdb.encodeJSON = encodeJSON;
23
+ rdb.formatDateOut = formatDateOut;
24
+ rdb.deleteFromSql = deleteFromSql;
25
+ rdb.selectForUpdateSql = selectForUpdateSql;
26
+ rdb.lastInsertedIsSeparate = false;
27
+ rdb.insertSql = insertSql;
28
+ rdb.insert = insert;
29
+ rdb.multipleStatements = true;
30
+ rdb.limitAndOffset = limitAndOffset;
31
+ rdb.accept = function(caller) {
32
+ caller.visitPg();
33
+ };
34
+ rdb.aggregateCount = 0;
35
+ rdb.quote = (name) => `"${name}"`;
36
+
37
+ if (readonly) {
38
+ rdb.dbClient = {
39
+ executeQuery: function(query, callback) {
40
+ pool.connect((err, client, done) => {
41
+ if (err) {
42
+ return callback(err);
43
+ }
44
+ try {
45
+ wrapQuery(client)(query, (err, res) => {
46
+ done();
47
+ callback(err, res);
48
+ });
49
+ } catch (e) {
50
+ done();
51
+ callback(e);
52
+ }
53
+ });
54
+ }
55
+ };
56
+ domain.rdb = rdb;
57
+ return (onSuccess) => onSuccess();
58
+ }
59
+
20
60
  return function(onSuccess, onError) {
21
61
  pool.connect(onConnected);
22
62
 
@@ -27,26 +67,8 @@ function newResolveTransaction(domain, pool) {
27
67
  return;
28
68
  }
29
69
  client.executeQuery = wrapQuery(client);
30
- client.streamQuery = wrapQueryStream(client);
31
- rdb.engine = 'pg';
32
70
  rdb.dbClient = client;
33
71
  rdb.dbClientDone = done;
34
- rdb.encodeBoolean = encodeBoolean;
35
- rdb.encodeDate = encodeDate;
36
- rdb.encodeJSON = encodeJSON;
37
- rdb.formatDateOut = formatDateOut;
38
- rdb.deleteFromSql = deleteFromSql;
39
- rdb.selectForUpdateSql = selectForUpdateSql;
40
- rdb.lastInsertedIsSeparate = false;
41
- rdb.insertSql = insertSql;
42
- rdb.insert = insert;
43
- rdb.multipleStatements = true;
44
- rdb.limitAndOffset = limitAndOffset;
45
- rdb.accept = function(caller) {
46
- caller.visitPg();
47
- };
48
- rdb.aggregateCount = 0;
49
- rdb.quote = (name) => `"${name}"`;
50
72
  domain.rdb = rdb;
51
73
  onSuccess();
52
74
  } catch (e) {
@@ -56,4 +78,4 @@ function newResolveTransaction(domain, pool) {
56
78
  };
57
79
  }
58
80
 
59
- module.exports = newResolveTransaction;
81
+ module.exports = newResolveTransaction;
package/src/sap/newDatabase.js CHANGED
@@ -47,7 +47,7 @@ function newDatabase(connectionString, poolOptions) {
47
47
 
48
48
  async function runInTransaction() {
49
49
  let result;
50
- let transaction = newTransaction(domain, pool);
50
+ let transaction = newTransaction(domain, pool, options);
51
51
  await new Promise(transaction)
52
52
  .then(begin)
53
53
  .then(fn)
@@ -59,7 +59,7 @@ function newDatabase(connectionString, poolOptions) {
59
59
 
60
60
  function run() {
61
61
  let p;
62
- let transaction = newTransaction(domain, pool);
62
+ let transaction = newTransaction(domain, pool, options);
63
63
  if (useHook())
64
64
  p = new Promise(transaction);
65
65
  else
package/src/sap/newTransaction.js CHANGED
@@ -8,12 +8,63 @@ const insertSql = require('./insertSql');
8
8
  const insert = require('./insert');
9
9
  const limitAndOffset = require('./limitAndOffset');
10
10
 
11
- function newResolveTransaction(domain, pool) {
11
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
12
12
  var rdb = {poolFactory: pool};
13
13
  if (!pool.connect) {
14
14
  pool = pool();
15
15
  rdb.pool = pool;
16
16
  }
17
+ rdb.engine = 'sap';
18
+ rdb.encodeBoolean = encodeBoolean;
19
+ rdb.decodeJSON = decodeJSON;
20
+ rdb.encodeJSON = JSON.stringify;
21
+ rdb.deleteFromSql = deleteFromSql;
22
+ rdb.selectForUpdateSql = selectForUpdateSql;
23
+ rdb.formatDateOut = formatDateOut;
24
+ rdb.lastInsertedSql = lastInsertedSql;
25
+ rdb.insertSql = insertSql;
26
+ rdb.insert = insert;
27
+ rdb.lastInsertedIsSeparate = true;
28
+ rdb.multipleStatements = false;
29
+ rdb.begin = 'BEGIN TRANSACTION';
30
+ rdb.limit = (span) => {
31
+ if (span.offset)
32
+ return '';
33
+ else if (span.limit || span.limit === 0)
34
+ return 'TOP ' + span.limit;
35
+ else
36
+ return '';
37
+ };
38
+ rdb.limitAndOffset = limitAndOffset;
39
+ rdb.accept = function(caller) {
40
+ caller.visitSap();
41
+ };
42
+ rdb.aggregateCount = 0;
43
+ rdb.quote = (name) => `[${name}]`;
44
+
45
+ if (readonly) {
46
+ rdb.dbClient = {
47
+ executeQuery: function(query, callback) {
48
+ pool.connect((err, client, done) => {
49
+ if (err) {
50
+ return callback(err);
51
+ }
52
+ try {
53
+ wrapQuery(client)(query, (err, res) => {
54
+ done();
55
+ callback(err, res);
56
+ });
57
+ } catch (e) {
58
+ done();
59
+ callback(e);
60
+ }
61
+ });
62
+ }
63
+ };
64
+ domain.rdb = rdb;
65
+ return (onSuccess) => onSuccess();
66
+ }
67
+
17
68
 
18
69
  return function(onSuccess, onError) {
19
70
  pool.connect(onConnected);
@@ -25,35 +76,8 @@ function newResolveTransaction(domain, pool) {
25
76
  return;
26
77
  }
27
78
  client.executeQuery = wrapQuery(client);
28
- rdb.engine = 'sap';
29
79
  rdb.dbClient = client;
30
80
  rdb.dbClientDone = done;
31
- rdb.encodeBoolean = encodeBoolean;
32
- rdb.decodeJSON = decodeJSON;
33
- rdb.encodeJSON = JSON.stringify;
34
- rdb.deleteFromSql = deleteFromSql;
35
- rdb.selectForUpdateSql = selectForUpdateSql;
36
- rdb.formatDateOut = formatDateOut;
37
- rdb.lastInsertedSql = lastInsertedSql;
38
- rdb.insertSql = insertSql;
39
- rdb.insert = insert;
40
- rdb.lastInsertedIsSeparate = true;
41
- rdb.multipleStatements = false;
42
- rdb.begin = 'BEGIN TRANSACTION';
43
- rdb.limit = (span) => {
44
- if (span.offset)
45
- return '';
46
- else if (span.limit || span.limit === 0)
47
- return 'TOP ' + span.limit;
48
- else
49
- return '';
50
- };
51
- rdb.limitAndOffset = limitAndOffset;
52
- rdb.accept = function(caller) {
53
- caller.visitSap();
54
- };
55
- rdb.aggregateCount = 0;
56
- rdb.quote = (name) => `[${name}]`;
57
81
  domain.rdb = rdb;
58
82
  onSuccess();
59
83
  } catch (e) {
package/src/sqlite/newDatabase.js CHANGED
@@ -47,7 +47,7 @@ function newDatabase(connectionString, poolOptions) {
47
47
 
48
48
  async function runInTransaction() {
49
49
  let result;
50
- let transaction = newTransaction(domain, pool);
50
+ let transaction = newTransaction(domain, pool, options);
51
51
  await new Promise(transaction)
52
52
  .then(begin)
53
53
  .then(fn)
@@ -59,7 +59,7 @@ function newDatabase(connectionString, poolOptions) {
59
59
 
60
60
  function run() {
61
61
  let p;
62
- let transaction = newTransaction(domain, pool);
62
+ let transaction = newTransaction(domain, pool, options);
63
63
  if (useHook())
64
64
  p = new Promise(transaction);
65
65
  else
package/src/sqlite/newTransaction.js CHANGED
@@ -7,12 +7,52 @@ const limitAndOffset = require('./limitAndOffset');
7
7
  const insertSql = require('./insertSql');
8
8
  const insert = require('./insert');
9
9
 
10
- function newResolveTransaction(domain, pool) {
10
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
11
11
  var rdb = {poolFactory: pool};
12
12
  if (!pool.connect) {
13
13
  pool = pool();
14
14
  rdb.pool = pool;
15
15
  }
16
+ rdb.engine = 'sqlite';
17
+ rdb.encodeBoolean = encodeBoolean;
18
+ rdb.decodeJSON = decodeJSON;
19
+ rdb.encodeJSON = JSON.stringify;
20
+ rdb.deleteFromSql = deleteFromSql;
21
+ rdb.selectForUpdateSql = selectForUpdateSql;
22
+ rdb.lastInsertedSql = lastInsertedSql;
23
+ rdb.insertSql = insertSql;
24
+ rdb.insert = insert;
25
+ rdb.lastInsertedIsSeparate = true;
26
+ rdb.multipleStatements = false;
27
+ rdb.limitAndOffset = limitAndOffset;
28
+ rdb.accept = function(caller) {
29
+ caller.visitSqlite();
30
+ };
31
+ rdb.aggregateCount = 0;
32
+ rdb.quote = (name) => `"${name}"`;
33
+
34
+ if (readonly) {
35
+ rdb.dbClient = {
36
+ executeQuery: function(query, callback) {
37
+ pool.connect((err, client, done) => {
38
+ if (err) {
39
+ return callback(err);
40
+ }
41
+ try {
42
+ wrapQuery(client)(query, (err, res) => {
43
+ done();
44
+ callback(err, res);
45
+ });
46
+ } catch (e) {
47
+ done();
48
+ callback(e);
49
+ }
50
+ });
51
+ }
52
+ };
53
+ domain.rdb = rdb;
54
+ return (onSuccess) => onSuccess();
55
+ }
16
56
 
17
57
  return function(onSuccess, onError) {
18
58
  pool.connect(onConnected);
@@ -24,25 +64,8 @@ function newResolveTransaction(domain, pool) {
24
64
  return;
25
65
  }
26
66
  client.executeQuery = wrapQuery(client);
27
- rdb.engine = 'sqlite';
28
67
  rdb.dbClient = client;
29
68
  rdb.dbClientDone = done;
30
- rdb.encodeBoolean = encodeBoolean;
31
- rdb.decodeJSON = decodeJSON;
32
- rdb.encodeJSON = JSON.stringify;
33
- rdb.deleteFromSql = deleteFromSql;
34
- rdb.selectForUpdateSql = selectForUpdateSql;
35
- rdb.lastInsertedSql = lastInsertedSql;
36
- rdb.insertSql = insertSql;
37
- rdb.insert = insert;
38
- rdb.lastInsertedIsSeparate = true;
39
- rdb.multipleStatements = false;
40
- rdb.limitAndOffset = limitAndOffset;
41
- rdb.accept = function(caller) {
42
- caller.visitSqlite();
43
- };
44
- rdb.aggregateCount = 0;
45
- rdb.quote = (name) => `"${name}"`;
46
69
  domain.rdb = rdb;
47
70
  onSuccess();
48
71
  } catch (e) {
package/src/tedious/newDatabase.js CHANGED
@@ -47,7 +47,7 @@ function newDatabase(connectionString, poolOptions) {
47
47
 
48
48
  async function runInTransaction() {
49
49
  let result;
50
- let transaction = newTransaction(domain, pool);
50
+ let transaction = newTransaction(domain, pool, options);
51
51
  await new Promise(transaction)
52
52
  .then(begin)
53
53
  .then(fn)
@@ -60,7 +60,7 @@ function newDatabase(connectionString, poolOptions) {
60
60
 
61
61
  function run() {
62
62
  let p;
63
- let transaction = newTransaction(domain, pool);
63
+ let transaction = newTransaction(domain, pool, options);
64
64
  if (useHook())
65
65
  p = new Promise(transaction);
66
66
  else
package/src/tedious/newTransaction.js CHANGED
@@ -10,12 +10,64 @@ const formatJSONOut = require('./formatJSONOut');
10
10
  const insertSql = require('./insertSql');
11
11
  const insert = require('./insert');
12
12
 
13
- function newResolveTransaction(domain, pool) {
13
+ function newResolveTransaction(domain, pool, { readonly } = {}) {
14
14
  var rdb = {poolFactory: pool};
15
15
  if (!pool.connect) {
16
16
  pool = pool();
17
17
  rdb.pool = pool;
18
18
  }
19
+ rdb.engine = 'mssql';
20
+ rdb.getManyDto = getManyDto;
21
+ rdb.encodeBoolean = encodeBoolean;
22
+ rdb.decodeJSON = decodeJSON;
23
+ rdb.encodeJSON = JSON.stringify;
24
+ rdb.deleteFromSql = deleteFromSql;
25
+ rdb.selectForUpdateSql = selectForUpdateSql;
26
+ rdb.outputInsertedSql = outputInsertedSql;
27
+ rdb.lastInsertedIsSeparate = false;
28
+ rdb.insertSql = insertSql;
29
+ rdb.insert = insert;
30
+ rdb.formatDateOut = formatDateOut;
31
+ rdb.formatJSONOut = formatJSONOut;
32
+ rdb.multipleStatements = true;
33
+ rdb.begin = 'BEGIN TRANSACTION';
34
+ rdb.limit = (span) => {
35
+ if (span.offset)
36
+ return '';
37
+ else if (span.limit || span.limit === 0)
38
+ return 'TOP ' + span.limit;
39
+ else
40
+ return '';
41
+ };
42
+ rdb.limitAndOffset = limitAndOffset;
43
+ rdb.accept = function(caller) {
44
+ caller.visitSqlite();
45
+ };
46
+ rdb.aggregateCount = 0;
47
+ rdb.quote = (name) => `[${name}]`;
48
+
49
+ if (readonly) {
50
+ rdb.dbClient = {
51
+ executeQuery: function(query, callback) {
52
+ pool.connect((err, client, done) => {
53
+ if (err) {
54
+ return callback(err);
55
+ }
56
+ try {
57
+ wrapQuery(client)(query, (err, res) => {
58
+ done();
59
+ callback(err, res);
60
+ });
61
+ } catch (e) {
62
+ done();
63
+ callback(e);
64
+ }
65
+ });
66
+ }
67
+ };
68
+ domain.rdb = rdb;
69
+ return (onSuccess) => onSuccess();
70
+ }
19
71
 
20
72
  return function(onSuccess, onError) {
21
73
  pool.connect(onConnected);
@@ -27,37 +79,8 @@ function newResolveTransaction(domain, pool) {
27
79
  return;
28
80
  }
29
81
  client.executeQuery = wrapQuery(client);
30
- rdb.engine = 'mssql';
31
- rdb.getManyDto = getManyDto;
32
82
  rdb.dbClient = client;
33
83
  rdb.dbClientDone = done;
34
- rdb.encodeBoolean = encodeBoolean;
35
- rdb.decodeJSON = decodeJSON;
36
- rdb.encodeJSON = JSON.stringify;
37
- rdb.deleteFromSql = deleteFromSql;
38
- rdb.selectForUpdateSql = selectForUpdateSql;
39
- rdb.outputInsertedSql = outputInsertedSql;
40
- rdb.lastInsertedIsSeparate = false;
41
- rdb.insertSql = insertSql;
42
- rdb.insert = insert;
43
- rdb.formatDateOut = formatDateOut;
44
- rdb.formatJSONOut = formatJSONOut;
45
- rdb.multipleStatements = true;
46
- rdb.begin = 'BEGIN TRANSACTION';
47
- rdb.limit = (span) => {
48
- if (span.offset)
49
- return '';
50
- else if (span.limit || span.limit === 0)
51
- return 'TOP ' + span.limit;
52
- else
53
- return '';
54
- };
55
- rdb.limitAndOffset = limitAndOffset;
56
- rdb.accept = function(caller) {
57
- caller.visitSqlite();
58
- };
59
- rdb.aggregateCount = 0;
60
- rdb.quote = (name) => `[${name}]`;
61
84
  domain.rdb = rdb;
62
85
  onSuccess();
63
86
  } catch (e) {