sedentary 0.0.16 → 0.0.20

package/lib/minidb.js

@@ -16,45 +16,53 @@ class MiniDB extends db_1.DB {
             this.body = JSON.parse((await readFile(this.file)).toString());
         }
         catch (e) {
-            if (e.code !== "ENOENT")
+            const err = e;
+            if (err.code !== "ENOENT")
                 throw e;
         }
     }
     async dropConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName];
+        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
         for (const constraint of Object.keys(constraints.f).sort()) {
-            if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "f").length) {
-                this.log(`'${table.tableName}': Removing foreign key: '${constraint}'`);
-                delete constraints.f[constraint];
+            const arr = table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "f");
+            const dbOptions = arr.length ? arr[0].attribute.foreignKey.options : { onDelete: "delete", onUpdate: "delete" };
+            const inOptions = constraints.f[constraint].options;
+            if (dbOptions.onDelete !== inOptions.onDelete || dbOptions.onUpdate !== inOptions.onUpdate) {
+                this.syncLog(`'${table.tableName}': Removing foreign key: '${constraint}'`);
+                if (this.sync)
+                    delete constraints.f[constraint];
             }
         }
         for (const constraint of Object.keys(constraints.u).sort()) {
             if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "u").length) {
-                this.log(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].fieldName}'`);
-                delete constraints.u[constraint];
+                this.syncLog(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].on}'`);
+                if (this.sync)
+                    delete constraints.u[constraint];
             }
         }
         await this.save();
         return [];
     }
     async dropFields(table) {
-        const { fields } = this.body.tables[table.tableName];
-        for (const attribute in fields) {
+        const { fields } = this.body.tables[table.tableName] || { fields: {} };
+        for (const attribute of Object.keys(fields).sort()) {
             if (!table.findField(attribute)) {
-                this.log(`'${table.tableName}': Removing field: '${attribute}'`);
-                delete fields[attribute];
+                this.syncLog(`'${table.tableName}': Removing field: '${attribute}'`);
+                if (this.sync)
+                    delete fields[attribute];
             }
         }
         await this.save();
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async dropIndexes(table, constraintIndexes) {
-        const { indexes } = this.body.tables[table.tableName];
-        for (const name in indexes) {
+        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
+        for (const name of Object.keys(indexes).sort()) {
             const index = table.indexes.filter(_ => _.indexName === name);
             if (index.length === 0 || !this.indexesEq(indexes[name], index[0])) {
-                this.log(`'${table.tableName}': Removing index: '${name}'`);
-                delete indexes[name];
+                this.syncLog(`'${table.tableName}': Removing index: '${name}'`);
+                if (this.sync)
+                    delete indexes[name];
             }
         }
         await this.save();
@@ -64,72 +72,84 @@ class MiniDB extends db_1.DB {
         await writeFile(this.file, JSON.stringify(this.body));
     }
     async syncConstraints(table) {
-        const { constraints } = this.body.tables[table.tableName];
+        const { constraints } = this.body.tables[table.tableName] || { constraints: { f: {}, u: {} } };
         for (const constraint of table.constraints) {
-            const { constraintName, type } = constraint;
-            const { fieldName, foreignKey } = constraint.attribute;
+            const { attribute, constraintName, type } = constraint;
             if (!constraints[type][constraintName]) {
-                switch (type) {
-                    case "f":
-                        this.log(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${fieldName}' references '${foreignKey.tableName}(${foreignKey.fieldName})'`);
-                        constraints[type][constraintName] = { fieldName, toField: foreignKey.fieldName, toTable: foreignKey.tableName };
-                        break;
-                    case "u":
-                        this.log(`'${table.tableName}': Adding unique constraint on field: '${fieldName}'`);
-                        constraints[type][constraintName] = { fieldName };
-                        break;
+                if (type === "f") {
+                    const { fieldName, options, tableName } = attribute.foreignKey;
+                    const onDelete = options.onDelete !== "no action" ? ` on delete ${options.onDelete}` : "";
+                    const onUpdate = options.onUpdate !== "no action" ? ` on update ${options.onUpdate}` : "";
+                    this.syncLog(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${attribute.fieldName}' references '${tableName}(${fieldName})'${onDelete}${onUpdate}`);
+                    if (this.sync)
+                        constraints[type][constraintName] = { on: attribute.fieldName, options, fieldName, tableName };
+                }
+                else {
+                    this.syncLog(`'${table.tableName}': Adding unique constraint on field: '${attribute.fieldName}'`);
+                    if (this.sync)
+                        constraints[type][constraintName] = { on: attribute.fieldName };
                 }
             }
         }
         await this.save();
     }
     async syncIndexes(table) {
-        const { indexes } = this.body.tables[table.tableName];
+        const { indexes } = this.body.tables[table.tableName] || { indexes: {} };
         for (const index of table.indexes) {
             const { indexName } = index;
             if (!(indexName in indexes)) {
-                this.log(`'${table.tableName}': Adding index: '${indexName}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
-                indexes[indexName] = index;
+                this.syncLog(`'${table.tableName}': Adding index: '${indexName}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
+                if (this.sync)
+                    indexes[indexName] = index;
             }
         }
         await this.save();
     }
     async syncFields(table) {
         for (const attribute of table.attributes) {
-            const { fields } = this.body.tables[table.tableName];
+            const { fields } = this.body.tables[table.tableName] || { fields: {} };
             const { defaultValue, fieldName, notNull, size, type } = attribute;
             let field = fields[fieldName];
             if (!field) {
-                this.log(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
-                field = fields[fieldName] = { size, type };
+                this.syncLog(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
+                if (this.sync)
+                    field = fields[fieldName] = { size, type };
+                else
+                    field = {};
             }
             if (field.size !== size || field.type !== type) {
-                this.log(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
-                field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
+                this.syncLog(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
+                if (this.sync)
+                    field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
             }
             if (field.default) {
                 if (!defaultValue) {
-                    this.log(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
-                    delete field.default;
+                    this.syncLog(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
+                    if (this.sync)
+                        delete field.default;
                 }
                 else if (field.default !== defaultValue) {
-                    this.log(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
-                    field.default = defaultValue;
+                    this.syncLog(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
+                    if (this.sync)
+                        field.default = defaultValue;
                 }
             }
             else if (defaultValue) {
-                this.log(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
-                field.default = defaultValue;
+                this.syncLog(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
+                if (this.sync)
+                    field.default = defaultValue;
             }
             if (field.notNull) {
                 if (!notNull) {
-                    this.log(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
-                    delete field.notNull;
+                    this.syncLog(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
+                    if (this.sync)
+                        delete field.notNull;
                 }
             }
             else if (notNull) {
-                this.log(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
-                field.notNull = true;
+                this.syncLog(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
+                if (this.sync)
+                    field.notNull = true;
             }
         }
         await this.save();
@@ -145,20 +165,24 @@ class MiniDB extends db_1.DB {
                 }
                 else if (!this.body.tables[table.tableName].parent)
                     return;
-                this.log(`Removing table: '${table.tableName}'`);
-                delete this.body.tables[table.tableName];
+                this.syncLog(`Removing table: '${table.tableName}'`);
+                if (this.sync)
+                    delete this.body.tables[table.tableName];
             })();
         }
         if (!this.body.tables[table.tableName]) {
-            this.log(`Adding table: '${table.tableName}'`);
-            this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {}, indexes: {} };
+            this.syncLog(`Adding table: '${table.tableName}'`);
+            if (this.sync)
+                this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {}, indexes: {} };
             if (table.parent) {
-                this.log(`Setting parent: '${table.parent.tableName}' - to table: '${table.tableName}'`);
-                this.body.tables[table.tableName].parent = table.parent.tableName;
+                this.syncLog(`Setting parent: '${table.parent.tableName}' - to table: '${table.tableName}'`);
+                if (this.sync)
+                    this.body.tables[table.tableName].parent = table.parent.tableName;
             }
             if (table.autoIncrement && !this.body.next[table.tableName]) {
-                this.log(`Setting auto increment: '${table.tableName}'`);
-                this.body.next[table.tableName] = 1;
+                this.syncLog(`Setting auto increment: '${table.tableName}'`);
+                if (this.sync)
+                    this.body.next[table.tableName] = 1;
             }
         }
         await this.save();

package/lib/transaction.d.ts

@@ -0,0 +1,2 @@
+export declare class Transaction {
+}

package/lib/transaction.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+class Transaction {
+}
+exports.Transaction = Transaction;

package/package.json

@@ -5,16 +5,17 @@
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "16.11.10",
+    "@types/node": "17.0.5",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.4.0",
-    "@typescript-eslint/parser": "5.4.0",
-    "eslint": "8.3.0",
+    "@typescript-eslint/eslint-plugin": "5.8.1",
+    "@typescript-eslint/parser": "5.8.1",
+    "eslint": "8.5.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
-    "prettier": "2.5.0",
+    "prettier": "2.5.1",
     "ts-node": "10.4.0",
-    "typescript": "4.5.2",
+    "tsd": "0.19.0",
+    "typescript": "4.5.4",
     "yamljs": "0.3.0"
   },
   "engines": {
@@ -55,6 +56,23 @@
     "tsc": "tsc --declaration",
     "version": "node -r ts-node/register utils.ts version"
   },
+  "tsd": {
+    "compilerOptions": {
+      "alwaysStrict": true,
+      "declaration": true,
+      "esModuleInterop": true,
+      "module": "commonjs",
+      "noImplicitAny": true,
+      "noImplicitReturns": true,
+      "noImplicitThis": true,
+      "strict": true,
+      "strictBindCallApply": true,
+      "strictFunctionTypes": true,
+      "strictNullChecks": true,
+      "strictPropertyInitialization": true,
+      "target": "es2017"
+    }
+  },
   "types": "index.d.ts",
-  "version": "0.0.16"
+  "version": "0.0.20"
 }

package/utils.d.ts

@@ -0,0 +1 @@
+export {};

package/utils.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yamljs_1 = __importDefault(require("yamljs"));
+const fs_1 = require("fs");
+const { readFile, writeFile } = fs_1.promises;
+const { VERSION, npm_package_name } = process.env;
+const common = ["*.tgz", "coverage", "node_modules", "test.json", ""];
+const git = [".gitignore", ".npmignore", ".nyc_output", "docs/build", "docs/__pycache__", "index.d.ts", "index.js", "lib/*.d.ts", "lib/*.js"];
+const npm = [".*", "Makefile", "docs", "index.ts", "lib/db.ts", "lib/minidb.ts", "lib/transaction.ts", "sedentary-*", "test", "tsconfig.json", "utils.ts"];
+const descriptions = { sedentary: "", "sedentary-mysql": " - MySQL", "sedentary-pg": " - PostgreSQL", "sedentary-sqlite": " - SQLite" };
+const urls = { sedentary: "", "sedentary-mysql": "-mysql", "sedentary-pg": "-pg", "sedentary-sqlite": "-sqlite" };
+const deps = { sedentary: {}, "sedentary-mysql": {}, "sedentary-pg": { pg: "8.7.1", "pg-format": "1.0.4" }, "sedentary-sqlite": {} };
+const devd = { sedentary: {}, "sedentary-mysql": {}, "sedentary-pg": { "@types/pg": "8.6.3", "@types/pg-format": "1.0.2" }, "sedentary-sqlite": {} };
+const packagejson = {
+    author: "Daniele Ricci <daniele.icc@gmail.com> (https://github.com/iccicci)",
+    dependencies: {},
+    devDependencies: {
+        "@types/mocha": "9.0.0",
+        "@types/node": "17.0.5",
+        "@types/yamljs": "0.2.31",
+        "@typescript-eslint/eslint-plugin": "5.8.1",
+        "@typescript-eslint/parser": "5.8.1",
+        eslint: "8.5.0",
+        mocha: "9.1.3",
+        prettier: "2.5.1",
+        nyc: "15.1.0",
+        "ts-node": "10.4.0",
+        tsd: "0.19.0",
+        typescript: "4.5.4",
+        yamljs: "0.3.0"
+    },
+    engines: { node: ">=12.0" },
+    funding: { url: "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB" },
+    keywords: ["DB", "ORM", "database", "migration", "mysql", "postgresql", "sqlite"],
+    license: "MIT",
+    prettier: {
+        arrowParens: "avoid",
+        endOfLine: "lf",
+        jsxBracketSameLine: true,
+        printWidth: 200,
+        trailingComma: "none",
+        useTabs: false
+    },
+    readmeFilename: "README.md",
+    scripts: {
+        coverage: "nyc -r lcov -r text -r text-summary -r html mocha -r ts-node/register test/*ts",
+        gitignore: "node -r ts-node/register utils.ts gitignore",
+        npmignore: "node -r ts-node/register utils.ts npmignore",
+        packagejson: "node -r ts-node/register utils.ts packagejson",
+        test: "mocha -r ts-node/register test/*ts",
+        travis: "node -r ts-node/register utils.ts travis",
+        tsc: "tsc --declaration",
+        version: "node -r ts-node/register utils.ts version"
+    },
+    tsd: { compilerOptions: {} },
+    types: "index.d.ts"
+};
+const before_script_common = [
+    "curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter",
+    "chmod +x ./cc-test-reporter",
+    "./cc-test-reporter before-build"
+];
+const conditions = { sedentary: "", "sedentary-pg": "&& $PG_VERSION == 14 " };
+const travis = {
+    common: {
+        after_script: [`if [[ \`node --version\` =~ ^v16 ${conditions[npm_package_name]}]] ; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT ; fi`],
+        before_script: before_script_common,
+        language: "node_js",
+        node_js: ["16", "14", "12"],
+        script: "npm run coverage",
+        sudo: "required"
+    },
+    sedentary: { env: { global: ["CC_TEST_REPORTER_ID=1aa1f737e7bf7d2859a2c7d9a0d9634a0d9aa89e3a19476d576faa7d02a1d46f"] } },
+    "sedentary-pg": {
+        before_install: ["sudo service postgresql stop", "sudo service postgresql restart $PG_VERSION"],
+        before_script: [
+            ...before_script_common,
+            'psql -c "CREATE DATABASE sedentary;" -U postgres',
+            "psql -c \"ALTER DATABASE sedentary SET timezone TO 'GMT';\" -U postgres",
+            'export SPG=\'{"database":"sedentary","password":"postgres","user":"postgres"}\''
+        ],
+        env: {
+            global: ["CC_TEST_REPORTER_ID=c7519657dfea145349c1b7a98f7134f033c25f598b40ad5b077744eb4beb7c66"],
+            matrix: ["PG_VERSION=14", "PG_VERSION=13", "PG_VERSION=12", "PG_VERSION=11", "PG_VERSION=10"]
+        }
+    }
+};
+function sort(obj) {
+    const ret = {};
+    if (obj instanceof Array || !(obj instanceof Object))
+        return obj;
+    Object.entries(obj)
+        .sort(([a], [b]) => (a < b ? -1 : 1))
+        .forEach(([k, v]) => (ret[k] = sort(v)));
+    return ret;
+}
+(async function () {
+    if (process.argv[2] === "gitignore")
+        writeFile(".gitignore", [...git, ...common].join("\n"), "utf-8");
+    if (process.argv[2] === "npmignore")
+        writeFile(".npmignore", [...npm, ...common].join("\n"), "utf-8");
+    if (process.argv[2] === "travis")
+        writeFile(".travis.yml", yamljs_1.default.stringify(sort(Object.assign(Object.assign({}, travis.common), travis[npm_package_name])), 4, 2), "utf-8");
+    if (process.argv[2] === "packagejson") {
+        const bugs = `https://github.com/iccicci/sedentary${urls[npm_package_name]}/issues`;
+        const description = "The ORM which never needs to migrate" + descriptions[npm_package_name];
+        const homepage = `https://github.com/iccicci/sedentary${urls[npm_package_name]}#readme`;
+        const repository = `https://github.com/iccicci/sedentary${urls[npm_package_name]}`;
+        const pkg = JSON.parse(await readFile("package.json", "utf-8"));
+        const { compilerOptions } = JSON.parse(await readFile("tsconfig.json", "utf-8"));
+        const { name, version } = pkg;
+        const tsd = { compilerOptions };
+        let { dependencies, devDependencies } = pkg;
+        try {
+            const { version } = JSON.parse(await readFile("../package.json", "utf-8"));
+            dependencies = Object.assign(Object.assign({}, deps[npm_package_name]), { sedentary: version });
+            devDependencies = Object.assign(Object.assign({}, devDependencies), devd[npm_package_name]);
+        }
+        catch (e) { }
+        await writeFile("package.json", JSON.stringify(sort(Object.assign(Object.assign({}, packagejson), { bugs, dependencies, devDependencies, description, homepage, name, repository, tsd, version })), null, 2), "utf-8");
+    }
+    if (process.argv[2] === "version") {
+        const pkg = JSON.parse(await readFile("package.json", "utf-8"));
+        pkg.version = VERSION;
+        await writeFile("package.json", JSON.stringify(pkg, null, 2), "utf-8");
+    }
+})();

package/lib/log.d.ts

@@ -1,4 +0,0 @@
-export declare function createLogger(log: ((message: string) => void) | null | undefined): {
-    (...data: any[]): void;
-    (message?: any, ...optionalParams: any[]): void;
-};

package/lib/log.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = void 0;
-const console_1 = require("console");
-const stream_1 = require("stream");
-class Logger extends stream_1.Writable {
-    constructor(log) {
-        super();
-        this.log = log;
-    }
-    _write(chunk, encoding, callback) {
-        this.log(chunk.toString());
-        callback();
-    }
-}
-function createLogger(log) {
-    // eslint-disable-next-line no-console
-    return log ? new console_1.Console(new Logger(log)).log : log === null ? () => { } : console.log;
-}
-exports.createLogger = createLogger;

package/lib/log.ts

@@ -1,22 +0,0 @@
-import { Console } from "console";
-import { Writable } from "stream";
-
-class Logger extends Writable {
-  private log: (message: string) => void;
-
-  constructor(log: (message: string) => void) {
-    super();
-
-    this.log = log;
-  }
-
-  _write(chunk: Buffer, encoding: string, callback: () => void) {
-    this.log(chunk.toString());
-    callback();
-  }
-}
-
-export function createLogger(log: ((message: string) => void) | null | undefined) {
-  // eslint-disable-next-line no-console
-  return log ? new Console(new Logger(log)).log : log === null ? () => {} : console.log;
-}