@technicity/data-service-generator 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -0,0 +1,166 @@
+# 0.7.0 [2022.01.17]
+
+- Add support for MySQL 8
+
+# 0.5.12 [2021.11.18]
+
+- Add `$queryRaw`
+
+```ts
+await sdk.$queryRaw("SELECT * FROM Foo WHERE id = ?", [2]);
+```
+
+Use the `?` character as a placeholder for values that need to be escaped.
+
+# 0.5.12 [2021.11.18]
+
+- Add support for nested creates. All of the specified creates are wrapped in a transaction.
+
+```ts
+await sdk.postFoo({
+  foo: "blah",
+  barList: {
+    $create: [
+      {
+        note: "blah",
+        bazList: { $create: [{ baz: "asdf" }, { baz: "zzz" }] },
+      },
+      { note: "blah 2" },
+    ],
+  },
+});
+```
+
+In the above example, 5 records are created: 1 `Foo` record, 2 `Bar` records, and 2 `Baz` records.
+
+# 0.5.7 [2021.10.12]
+
+- Add `$nlike` operator. Equivalent to SQL's `NOT LIKE` operator.
+
+```ts
+await sdk.getFooList({
+  $where: { bar: { $nlike: "%baz%" } },
+});
+```
+
+# 0.5.5 [2021.10.12]
+
+- Add limit + offset pagination
+
+```ts
+await sdk.getFooListPaginated({
+  $paginate: { limit: 5, offset: 2 },
+});
+```
+
+# 0.5.0 [2021.10.08]
+
+- Add support for middleware
+
+Generated SDKs now have a `$use` method, which takes a single argument: your middleware function.
+
+Example middleware that logs the amount of time an operation took:
+
+```ts
+sdk.$use(async (params, next) => {
+  const start = process.hrtime();
+  const result = await next(params);
+  const end = process.hrtime(start);
+  console.log(`${params.resource}.${params.action} took ${end[1] / 1000000}ms`);
+  return result;
+});
+```
+
+## Migrating from 0.4.x
+
+1. `npm install -S @technicity/data-service-generator@0.5.0`
+2. Regenerate SDK
+
+# 0.4.0 [2021.09.17]
+
+- Implement operations on update for string, number fields
+
+## string
+
+### `$prepend`
+
+Prepend a string to the current value. If the current value is `null`, the value is not updated.
+
+```ts
+await sdk.patchFoo(
+  { id: 1 },
+  { bar: { $prepend: `BAZ_` }
+);
+```
+
+### `$append`
+
+Append a string to the current value. If the current value is `null`, the value is not updated.
+
+```ts
+await sdk.patchFoo(
+  { id: 1 },
+  { bar: { $append: `_BAZ` }
+);
+```
+
+## number
+
+### `$increment`
+
+Increment the current value. If the current value is `null`, the value is not updated.
+
+```ts
+await sdk.patchBar(
+  { id: 1 },
+  { foo: { $increment: 5 }
+);
+```
+
+### `$decrement`
+
+Decrement the current value. If the current value is `null`, the value is not updated.
+
+```ts
+await sdk.patchBar(
+  { id: 1 },
+  { foo: { $decrement: 5 }
+);
+```
+
+## Migrating from 0.3.x
+
+1. `npm install -S @technicity/data-service-generator@0.4.0`
+2. Regenerate SDK
+
+# 0.3.1 [2021.09.09]
+
+- [MSSQL] Allow passing custom `typeCast`
+
+# 0.3.0 [2021.09.08]
+
+- For the generated SDK, instead of specifying a `dialect`, specify a `runtime`. This reduces the need to regenerate SDKs, since updates and bugfixes to the runtime side can be obtained solely by updating the `@technicity/data-service-generator` version, instead of both updating the `@technicity/data-service-generator` version and regenerating the SDK. It also allows for custom runtimes that live outside this package. `@technicity/data-service-generator` ships with 3 runtimes: `RuntimeMySQL`, `RuntimeMSSQL`, `RuntimeKSQL`.
+- Add KSQL support
+- `driverOpts` -> `clientOpts`
+- Add `otherOpts` to allow passing extra runtime-specific options
+
+## Migrating from 0.2.x
+
+1. `npm install -S @technicity/data-service-generator@0.3.0`
+2. Regenerate SDK
+3. Update SDK instantiation:
+
+```diff
++ import { RuntimeMySQL } from "@technicity/data-service-generator/dist/runtime/RuntimeMySQL";
+
+const sdk = new SDK({
+- dialect: "mysql",
++ runtime: RuntimeMySQL,
+- driverOpts: {
++ clientOpts: {
+    database: "MY_DATABASE",
+    user: "MY_USER",
+    password: "MY_PASSWORD",
+  },
+});
+```

package/dist/generation/generate.js

@@ -15,7 +15,7 @@ const TSqlString = require("tsqlstring");
 const json_schema_to_typescript_1 = require("json-schema-to-typescript");
 const getDuplicates_1 = require("../lib/getDuplicates");
 const isNotNullOrUndefined_1 = require("../lib/isNotNullOrUndefined");
-const mysql = require("../mysql");
+const mysql_1 = require("../runtime/lib/mysql");
 // json-schema-to-typescript inlines everything. We don't want that,
 // so use `tsType`, and add imports manually.
 // https://github.com/bcherny/json-schema-to-typescript#custom-schema-properties
@@ -138,14 +138,14 @@ exports.generate = generate;
 function init(input) {
     const { database, user, password, host, port, server } = input;
     if (dialect === "mysql") {
-        mysql.init({
+        let mysql = new mysql_1.MySQL({
             user,
             password,
             host,
             port,
             database,
         });
-        query = mysql.query;
+        query = mysql.query.bind(mysql);
     }
     if (dialect === "mssql" || dialect === "ksql") {
         const pool = new mssql.ConnectionPool({
@@ -1240,7 +1240,7 @@ const getRelationsOneToMany = _.memoize(async function getRelationsOneToMany(tab
             nullable: false,
         };
     })));
-    return _.sortBy((x) => x.referencedTable, xs);
+    return _.sortBy((x) => x.referencedKey, _.sortBy((x) => x.referencedTable, xs));
 });
 async function getPrimaryColumn(table) {
     const tableMeta = await getTableMeta(table);

package/dist/runtime/RuntimeMySQL.js

@@ -10,15 +10,16 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _RuntimeMySQL_dialect, _RuntimeMySQL_middlewareHandler;
+var _RuntimeMySQL_dialect, _RuntimeMySQL_mysqlClient, _RuntimeMySQL_middlewareHandler;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeMySQL = void 0;
 const SqlString = require("sqlstring");
-const mysql_1 = require("../mysql");
+const MySQL_1 = require("./lib/MySQL");
 const shared_1 = require("./lib/shared");
 class RuntimeMySQL {
     constructor(clientOpts, otherOpts, artifacts) {
         _RuntimeMySQL_dialect.set(this, "mysql");
+        _RuntimeMySQL_mysqlClient.set(this, void 0);
         _RuntimeMySQL_middlewareHandler.set(this, void 0);
         __classPrivateFieldSet(this, _RuntimeMySQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
         if (otherOpts.supplementClientOpts) {
@@ -60,7 +61,7 @@ class RuntimeMySQL {
                 ...clientOpts,
             };
         }
-        (0, mysql_1.init)(clientOpts);
+        __classPrivateFieldSet(this, _RuntimeMySQL_mysqlClient, new MySQL_1.MySQL(clientOpts), "f");
     }
     async resolve(input) {
         return (0, shared_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {});
@@ -78,14 +79,14 @@ class RuntimeMySQL {
         return (0, shared_1._prepareWhere)(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
     }
     dbCall(q) {
-        return (0, mysql_1.query)(q);
+        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").query(q);
     }
     formatQuery(q, values) {
         return SqlString.format(q, values);
     }
     beginTransaction() {
-        return (0, mysql_1.beginTransaction)();
+        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction();
     }
 }
 exports.RuntimeMySQL = RuntimeMySQL;
-_RuntimeMySQL_dialect = new WeakMap(), _RuntimeMySQL_middlewareHandler = new WeakMap();
+_RuntimeMySQL_dialect = new WeakMap(), _RuntimeMySQL_mysqlClient = new WeakMap(), _RuntimeMySQL_middlewareHandler = new WeakMap();

package/dist/runtime/lib/mysql.d.ts

@@ -0,0 +1,7 @@
+export declare class MySQL {
+    pool: any;
+    constructor(opts: any);
+    query(...args: any[]): any;
+    beginTransaction(): Promise<any>;
+    getConnection(): Promise<any>;
+}

package/dist/runtime/lib/mysql.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQL = void 0;
+const mysql = require("mysql");
+const P = require("bluebird");
+P.promisifyAll(require("mysql/lib/Connection").prototype);
+P.promisifyAll(require("mysql/lib/Pool").prototype);
+class MySQL {
+    constructor(opts) {
+        this.pool = mysql.createPool(opts);
+    }
+    // http://bluebirdjs.com/docs/api/promise.using.html
+    query(...args) {
+        return P.using(this.getConnection(), (connection) => connection.queryAsync(...args));
+    }
+    async beginTransaction() {
+        return P.using(this.getConnection(), async (connection) => {
+            async function handleError(err) {
+                await connection.rollbackAsync();
+                throw err;
+            }
+            await connection.beginTransactionAsync();
+            return {
+                commit: () => connection.commitAsync().catch(handleError),
+                dbCall: (q) => connection.queryAsync(q).catch(handleError),
+            };
+        });
+    }
+    // http://bluebirdjs.com/docs/api/disposer.html
+    async getConnection() {
+        return this.pool
+            .getConnectionAsync()
+            .disposer((connection) => connection.release());
+    }
+}
+exports.MySQL = MySQL;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "main": "./dist/index.js",
   "files": [
     "dist"
   ],
   "scripts": {
     "compile": "rm -rf dist && tsc",
-    "create-database": "env-cmd node ./test/mysql/create-database.js && env-cmd node ./test/mssql/create-database.js",
-    "generate": "npm run compile && npm run create-database && env-cmd node ./test/mysql/generate.js && env-cmd node ./test/mssql/generate.js",
+    "create-database": "env-cmd node ./test/mysql/create-database.js && env-cmd node ./test/mysql8/create-database.js && env-cmd node ./test/mssql/create-database.js",
+    "generate": "npm run compile && npm run create-database && env-cmd node ./test/mysql/generate.js && env-cmd node ./test/mysql8/generate.js && env-cmd node ./test/mssql/generate.js",
     "test": "npm run generate && env-cmd mocha ./test/addNullFallbacks.test.js && env-cmd mocha ./test/stringifyWhere.test.js && env-cmd mocha ./test/test.js"
   },
   "dependencies": {

package/dist/mysql.d.ts

@@ -1,3 +0,0 @@
-export function init(opts: any): void;
-export function query(...args: any[]): any;
-export function beginTransaction(): Promise<any>;

package/dist/mysql.js

@@ -1,35 +0,0 @@
-"use strict";
-const mysql = require("mysql");
-const Promise = require("bluebird");
-Promise.promisifyAll(require("mysql/lib/Connection").prototype);
-Promise.promisifyAll(require("mysql/lib/Pool").prototype);
-let pool;
-function init(opts) {
-    pool = mysql.createPool(opts);
-}
-// http://bluebirdjs.com/docs/api/disposer.html
-async function getConnection() {
-    return pool
-        .getConnectionAsync()
-        .disposer((connection) => connection.release());
-}
-// http://bluebirdjs.com/docs/api/promise.using.html
-function query(...args) {
-    return Promise.using(getConnection(), (connection) => connection.queryAsync(...args));
-}
-async function beginTransaction() {
-    return Promise.using(getConnection(), async (connection) => {
-        async function handleError(err) {
-            await connection.rollbackAsync();
-            throw err;
-        }
-        await connection.beginTransactionAsync();
-        return {
-            commit: () => connection.commitAsync().catch(handleError),
-            dbCall: (q) => connection.queryAsync(q).catch(handleError),
-        };
-    });
-}
-module.exports.init = init;
-module.exports.query = query;
-module.exports.beginTransaction = beginTransaction;