sedentary 0.0.10 → 0.0.14

package/lib/db.d.ts

@@ -1,50 +1,57 @@
-export declare class Record {
+export declare type Natural = Date | Record<string, unknown> | boolean | number | string;
+export declare class Entry {
     init(): void;
     save(): Promise<boolean>;
 }
-export declare class Type<N extends unknown, R extends unknown> {
+export declare class Type<N extends Natural, E> {
     base: unknown;
+    entry?: E;
     native?: N;
-    record?: R;
-    size: number;
+    size?: number;
     type: string;
-    constructor(from: Partial<Type<unknown, unknown>>);
-}
-interface IMeta {
-    init: () => void;
-    methods: {
-        [key: string]: () => unknown;
+    foreignKey?: {
+        attributeName: string;
+        fieldName: string;
+        tableName: string;
     };
-    primaryKey: string;
-    tableName: string;
+    constructor(from: Type<N, E>);
 }
-export declare class Meta<N extends unknown, R extends Record> extends Type<N, R> {
+export declare class Meta<N extends Natural, E> extends Type<N, E> {
     init: () => void;
+    isModel?: () => boolean;
     methods: {
         [key: string]: () => unknown;
     };
     primaryKey: string;
     tableName: string;
-    constructor(options: IMeta);
-    isModel(): boolean;
+    constructor(from: Meta<N, E>);
 }
-export declare class Field<N extends unknown, R extends unknown> extends Type<N, R> {
+export declare class Attribute<N extends Natural, E> extends Type<N, E> {
+    attributeName: string;
     defaultValue?: unknown;
-    fieldName?: string;
-    notNull?: boolean;
+    fieldName: string;
+    notNull: boolean;
+    tableName: string;
     unique?: boolean;
-    constructor(from: Partial<Field<N, R>>);
+    constructor(from: Attribute<N, E>);
 }
 export interface Constraint {
-    field: string;
-    name: string;
+    attribute: Attribute<Natural, unknown>;
+    constraintName: string;
     type: "f" | "u";
 }
+export interface Index {
+    fields: string[];
+    indexName: string;
+    type: "btree" | "hash";
+    unique: boolean;
+}
 interface ITable {
+    attributes: Attribute<Natural, unknown>[];
     constraints: Constraint[];
-    fields: Field<unknown, unknown>[];
+    indexes: Index[];
     oid?: number;
-    parent: Meta<unknown, Record>;
+    parent: Meta<Natural, unknown>;
     primaryKey: string;
     sync: boolean;
     tableName: string;
@@ -60,17 +67,19 @@ export declare abstract class DB {
         [key: string]: Table;
     };
     tablesArr: Table[];
-    protected log: (message: string) => void;
+    protected log: (...data: unknown[]) => void;
     abstract connect(): Promise<void>;
     abstract end(): Promise<void>;
     constructor(log: (message: string) => void);
     addTable(table: Table): void;
+    protected indexesEq(a: Index, b: Index): boolean;
     sync(): Promise<void>;
-    abstract dropConstraints(table: Table): Promise<void>;
+    abstract dropConstraints(table: Table): Promise<number[]>;
     abstract dropFields(table: Table): Promise<void>;
-    abstract dropIndexes(table: Table): Promise<void>;
+    abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
     abstract syncConstraints(table: Table): Promise<void>;
     abstract syncFields(table: Table): Promise<void>;
+    abstract syncIndexes(table: Table): Promise<void>;
     abstract syncSequence(table: Table): Promise<void>;
     abstract syncTable(table: Table): Promise<void>;
 }

package/lib/db.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB = exports.Table = exports.Field = exports.Meta = exports.Type = exports.Record = void 0;
-class Record {
+exports.DB = exports.Table = exports.Attribute = exports.Meta = exports.Type = exports.Entry = void 0;
+class Entry {
     init() { }
     async save() {
         return false;
     }
 }
-exports.Record = Record;
+exports.Entry = Entry;
 class Type {
     constructor(from) {
         Object.assign(this, from);
@@ -15,21 +15,17 @@ class Type {
 }
 exports.Type = Type;
 class Meta extends Type {
-    constructor(options) {
-        super({ size: 0, type: "" });
-        Object.assign(this, options);
-    }
-    isModel() {
-        return true;
+    constructor(from) {
+        super(from);
     }
 }
 exports.Meta = Meta;
-class Field extends Type {
+class Attribute extends Type {
     constructor(from) {
         super(from);
     }
 }
-exports.Field = Field;
+exports.Attribute = Attribute;
 function autoImplement() {
     return class {
         constructor(defaults) {
@@ -61,16 +57,29 @@ class DB {
         this.tables[table.tableName] = table;
         this.tablesArr.push(table);
     }
+    indexesEq(a, b) {
+        if (a.fields.length !== b.fields.length)
+            return false;
+        for (const i in a.fields)
+            if (a.fields[i] !== b.fields[i])
+                return false;
+        if (a.type !== b.type)
+            return false;
+        if (a.unique !== b.unique)
+            return false;
+        return true;
+    }
     async sync() {
         for (const i in this.tablesArr) {
             const table = this.tablesArr[i];
             await this.syncTable(table);
-            await this.dropConstraints(table);
-            await this.dropIndexes(table);
+            const indexes = await this.dropConstraints(table);
+            await this.dropIndexes(table, indexes);
             await this.dropFields(table);
             await this.syncFields(table);
             await this.syncSequence(table);
             await this.syncConstraints(table);
+            await this.syncIndexes(table);
         }
     }
 }

package/lib/log.d.ts

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

package/lib/log.js

@@ -0,0 +1,20 @@
+"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

@@ -0,0 +1,22 @@
+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;
+}

package/lib/minidb.d.ts

@@ -4,12 +4,13 @@ export declare class MiniDB extends DB {
     private file;
     constructor(filename: string, log: (message: string) => void);
     connect(): Promise<void>;
-    dropConstraints(table: Table): Promise<void>;
+    dropConstraints(table: Table): Promise<number[]>;
     dropFields(table: Table): Promise<void>;
-    dropIndexes(table: Table): Promise<void>;
+    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
     end(): Promise<void>;
     save(): Promise<void>;
     syncConstraints(table: Table): Promise<void>;
+    syncIndexes(table: Table): Promise<void>;
     syncFields(table: Table): Promise<void>;
     syncSequence(table: Table): Promise<void>;
     syncTable(table: Table): Promise<void>;

package/lib/minidb.js

@@ -22,62 +22,114 @@ class MiniDB extends db_1.DB {
     }
     async dropConstraints(table) {
         const { constraints } = this.body.tables[table.tableName];
-        for (const constraint in constraints.u) {
-            if (!table.constraints.filter(({ field, type }) => field === constraint && type === "u").length) {
-                this.log(`'${table.tableName}': Removing unique constraint on field: '${constraint}'`);
+        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];
+            }
+        }
+        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];
             }
         }
         await this.save();
+        return [];
     }
     async dropFields(table) {
         const { fields } = this.body.tables[table.tableName];
-        for (const field in fields) {
-            if (table.fields.filter(f => f.fieldName === field).length === 0) {
-                this.log(`'${table.tableName}': Removing field: '${field}'`);
-                delete fields[field];
+        for (const attribute in fields) {
+            if (table.attributes.filter(f => f.fieldName === attribute).length === 0) {
+                this.log(`'${table.tableName}': Removing field: '${attribute}'`);
+                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 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];
             }
         }
         await this.save();
     }
-    async dropIndexes(table) { }
     async end() { }
     async save() {
         await writeFile(this.file, JSON.stringify(this.body));
     }
     async syncConstraints(table) {
         const { constraints } = this.body.tables[table.tableName];
-        for (const i in table.constraints) {
-            const constraint = table.constraints[i];
-            if (!constraints[constraint.type][constraint.field]) {
-                this.log(`'${table.tableName}': Adding unique constraint on field: '${constraint.field}'`);
-                constraints[constraint.type][constraint.field] = true;
+        for (const constraint of table.constraints) {
+            const { constraintName, type } = constraint;
+            const { fieldName, foreignKey } = constraint.attribute;
+            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;
+                }
+            }
+        }
+        await this.save();
+    }
+    async syncIndexes(table) {
+        const { indexes } = this.body.tables[table.tableName];
+        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;
             }
         }
         await this.save();
     }
     async syncFields(table) {
-        for (const i in table.fields) {
-            const field = table.fields[i];
+        for (const attribute of table.attributes) {
             const { fields } = this.body.tables[table.tableName];
-            const { size, type } = field;
-            if (!fields[field.fieldName]) {
-                this.log(`'${table.tableName}': Adding field: '${field.fieldName}' '${type}' '${size}'`);
-                fields[field.fieldName] = { size, type };
+            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 };
+            }
+            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 });
             }
-            if (fields[field.fieldName].size !== size || fields[field.fieldName].type !== type) {
-                this.log(`'${table.tableName}': Changing field type: '${field.fieldName}' '${type}' '${size}'`);
-                fields[field.fieldName] = { size, type };
+            if (field.default) {
+                if (!defaultValue) {
+                    this.log(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
+                    delete field.default;
+                }
+                else if (field.default !== defaultValue) {
+                    this.log(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
+                    field.default = defaultValue;
+                }
             }
-            if (fields[field.fieldName].default) {
-                if (!field.defaultValue)
-                    this.log(`'${table.tableName}': Dropping default value for field: '${field.fieldName}'`);
-                else if (fields[field.fieldName].default !== field.defaultValue)
-                    this.log(`'${table.tableName}': Changing default value to '${field.defaultValue}' for field: '${field.fieldName}'`);
+            else if (defaultValue) {
+                this.log(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
+                field.default = defaultValue;
+            }
+            if (field.notNull) {
+                if (!notNull) {
+                    this.log(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
+                    delete field.notNull;
+                }
             }
-            else if (field.defaultValue) {
-                this.log(`'${table.tableName}': Setting default value '${field.defaultValue}' for field: '${field.fieldName}'`);
-                fields[field.fieldName].default = field.defaultValue;
+            else if (notNull) {
+                this.log(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
+                field.notNull = true;
             }
         }
         await this.save();
@@ -99,7 +151,7 @@ class MiniDB extends db_1.DB {
         }
         if (!this.body.tables[table.tableName]) {
             this.log(`Adding table: '${table.tableName}'`);
-            this.body.tables[table.tableName] = { constraints: { f: {}, u: {} }, fields: {} };
+            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;

package/package.json

@@ -4,21 +4,21 @@
   "dependencies": {},
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
-    "@types/mocha": "8.2.0",
-    "@types/node": "14.14.16",
+    "@types/mocha": "9.0.0",
+    "@types/node": "16.11.7",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "4.11.1",
-    "@typescript-eslint/parser": "4.11.1",
-    "eslint": "7.16.0",
-    "mocha": "8.2.1",
+    "@typescript-eslint/eslint-plugin": "5.3.1",
+    "@typescript-eslint/parser": "5.3.1",
+    "eslint": "8.2.0",
+    "mocha": "9.1.3",
     "nyc": "15.1.0",
-    "prettier": "2.2.1",
-    "ts-node": "9.1.1",
-    "typescript": "4.1.3",
+    "prettier": "2.4.1",
+    "ts-node": "10.4.0",
+    "typescript": "4.4.4",
     "yamljs": "0.3.0"
   },
   "engines": {
-    "node": ">=10.0"
+    "node": ">=12.0"
   },
   "homepage": "https://github.com/iccicci/sedentary#readme",
   "keywords": [
@@ -53,5 +53,5 @@
     "version": "node -r ts-node/register utils.ts version"
   },
   "types": "index.d.ts",
-  "version": "0.0.10"
-}
+  "version": "0.0.14"
+}

package/sedentary-pg/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Daniele Ricci
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/sedentary-pg/README.md

@@ -0,0 +1,32 @@
+# sedentary-pg
+
+[![Build Status][travis-badge]][travis-url]
+[![Code Climate][code-badge]][code-url]
+[![Test Coverage][cover-badge]][code-url]
+
+[![NPM version][npm-badge]][npm-url]
+[![NPM downloads][npm-downloads-badge]][npm-url]
+[![Stars][stars-badge]][github-url]
+
+[![Types][types-badge]][npm-url]
+[![Dependents][deps-badge]][npm-url]
+[![Donate][donate-badge]][donate-url]
+
+[code-badge]: https://codeclimate.com/github/iccicci/sedentary-pg/badges/gpa.svg
+[code-url]: https://codeclimate.com/github/iccicci/sedentary-pg
+[cover-badge]: https://codeclimate.com/github/iccicci/sedentary-pg/badges/coverage.svg
+[deps-badge]: https://badgen.net/npm/dependents/sedentary-pg?icon=npm&cache=300
+[donate-badge]: https://badgen.net/badge/donate/bitcoin?icon=bitcoin&cache=300
+[donate-url]: https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB
+[github-url]: https://github.com/iccicci/sedentary-pg
+[npm-downloads-badge]: https://badgen.net/npm/dw/sedentary-pg?icon=npm&cache=300
+[npm-badge]: https://badgen.net/npm/v/sedentary-pg?color=green&icon=npm&cache=300
+[npm-url]: https://www.npmjs.com/package/sedentary-pg
+[stars-badge]: https://badgen.net/github/stars/iccicci/sedentary-pg?icon=github&cache=300
+[travis-badge]: https://badgen.net/travis/iccicci/sedentary-pg?icon=travis&cache=300
+[travis-url]: https://app.travis-ci.com/github/iccicci/sedentary-pg
+[types-badge]: https://badgen.net/npm/types/sedentary-pg?color=green&icon=typescript&cache=300
+
+# under development
+
+https://bucardo.org/postgres_all_versions.html