sedentary 0.0.12 → 0.0.16

package/README.md

@@ -9,6 +9,7 @@
 [![Stars][stars-badge]][github-url]
 
 [![Types][types-badge]][npm-url]
+[![Documentation][doc-badge]][doc-url]
 [![Dependents][deps-badge]][npm-url]
 [![Donate][donate-badge]][donate-url]
 
@@ -16,6 +17,8 @@
 [code-url]: https://codeclimate.com/github/iccicci/sedentary
 [cover-badge]: https://codeclimate.com/github/iccicci/sedentary/badges/coverage.svg
 [deps-badge]: https://badgen.net/npm/dependents/sedentary?icon=npm&cache=300
+[doc-badge]: https://readthedocs.org/projects/sedentary/badge/?version=latest
+[doc-url]: https://sedentary.readthedocs.io/
 [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

package/index.d.ts

@@ -1,79 +1,117 @@
-import { DB, Index, Meta, Record, Type } from "./lib/db";
-declare type TypeDefinition<N extends unknown, R extends unknown> = (() => Type<N, R>) | Type<N, R>;
-interface FieldOptions<N extends unknown, R extends unknown> {
+import { DB, Entry, Meta, Natural, Type } from "./lib/db";
+export { Entry, Natural, Type } from "./lib/db";
+export declare type TypeDefinition<N extends Natural, E> = (() => Type<N, E>) | Type<N, E>;
+export interface AttributeOptions<N extends Natural, E> {
     defaultValue?: N;
     fieldName?: string;
     notNull?: boolean;
-    type: TypeDefinition<N, R>;
+    type: TypeDefinition<N, E>;
     unique?: boolean;
 }
-declare type FieldDefinition<N extends unknown, R extends unknown> = TypeDefinition<N, R> | FieldOptions<N, R>;
-declare type FieldsDefinition = {
-    [key: string]: FieldDefinition<unknown, unknown>;
+export declare type AttributeDefinition<N extends Natural, E> = TypeDefinition<N, E> | AttributeOptions<N, E>;
+export declare type AttributesDefinition = {
+    [key: string]: AttributeDefinition<Natural, unknown>;
 };
-declare type ForeignKeyFileds<T, k> = T extends FieldDefinition<unknown, infer R> ? (R extends Record ? k : never) : never;
-declare type ForeignKey<T> = T extends FieldDefinition<unknown, infer R> ? () => Promise<R> : never;
-declare type Keys<F extends FieldsDefinition> = {
-    [f in keyof F]?: ForeignKeyFileds<F[f], f>;
+declare type KeysAttributes<T, k> = T extends AttributeDefinition<Natural, infer E> ? (E extends Entry ? k : never) : never;
+declare type Keys<F extends AttributesDefinition> = {
+    [f in keyof F]?: KeysAttributes<F[f], f>;
 }[keyof F];
 declare type Methods<T> = {
     [key: string]: (this: T) => unknown;
 };
 declare type Native__<T> = T extends Type<infer N, unknown> ? N : never;
-declare type Native_<T> = T extends () => Type<infer N, infer R> ? Native__<Type<N, R>> : Native__<T>;
-declare type Native<T> = T extends FieldOptions<infer N, infer R> ? Native__<Type<N, R>> : Native_<T>;
-declare type Parent<T> = T extends Meta<unknown, infer R> ? R : never;
-declare type Options<M, T> = {
-    indexes?: {
-        [key: string]: Index;
-    };
+declare type Native_<T> = T extends () => Type<infer N, infer E> ? Native__<Type<N, E>> : Native__<T>;
+declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native__<Type<N, E>> : Native_<T>;
+declare type Parent<T> = T extends Meta<Natural, infer E> ? E : never;
+export declare type IndexAttributes = string[] | string;
+export interface IndexOptions {
+    attributes: IndexAttributes;
+    type?: "btree" | "hash";
+    unique?: boolean;
+}
+export declare type IndexDefinition = IndexAttributes | IndexOptions;
+export declare type IndexesDefinition = {
+    [key: string]: IndexDefinition;
+};
+declare type BaseModelOptions<T> = {
+    indexes?: IndexesDefinition;
     init?: (this: T) => void;
-    methods?: M;
     sync?: boolean;
     tableName?: string;
 };
-declare type Model<F extends FieldsDefinition, M> = {
-    [f in keyof F]?: Native<F[f]>;
+export declare type ModelOptions<K extends string, M extends Methods<T>, P extends Meta<Natural, Entry>, T extends Entry> = BaseModelOptions<T> & {
+    int8id?: boolean;
+    methods?: M;
+    parent?: P;
+    primaryKey?: K;
+};
+declare type ForeignKey<T> = T extends AttributeDefinition<Natural, infer E> ? () => Promise<E> : never;
+declare type ModelWithMetods<A extends AttributesDefinition, M> = {
+    [a in keyof A]?: Native<A[a]>;
 } & {
-    [f in Keys<F> & string as `${f}Load`]?: ForeignKey<F[f]>;
+    [a in Keys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
 } & M;
-declare type Ancestor<F, N extends unknown, T extends Record> = (new () => T) & {
-    [f in keyof F]?: Meta<Native<F[f]>, T>;
+declare type Model<A extends AttributesDefinition> = {
+    [a in keyof A]?: Native<A[a]>;
+} & {
+    [a in Keys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
+};
+declare type Ancestor<A, N extends Natural, T extends Entry> = (new () => T) & {
+    [a in keyof A]?: Meta<Native<A[a]>, T>;
 } & {
     load: (boh: boolean) => Promise<T[]>;
 } & Meta<N, T>;
-export interface SchemaOptions {
-    log?: (message: string) => void;
+export interface SedentaryOptions {
+    log?: ((message: string) => void) | null;
+    serverless?: boolean;
     sync?: boolean;
 }
 export declare class Sedentary {
     protected db: DB;
-    protected log: (message: string) => void;
-    private sync;
+    protected log: (...data: unknown[]) => void;
+    protected sync: boolean;
     private models;
-    constructor(filename: string, options?: SchemaOptions);
+    constructor(filename: string, options?: SedentaryOptions);
     DATETIME(): Type<Date, unknown>;
-    FKEY<N extends unknown, R extends Record>(record: Type<N, R>): Type<N, R>;
+    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>): Type<N, E>;
     INT(size?: number): Type<number, unknown>;
     INT8(): Type<string, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;
     connect(): Promise<void>;
     end(): Promise<void>;
-    model<F extends FieldsDefinition, M extends Methods<T>, T extends Record & {
+    model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
+        id?: string;
+    } & ModelWithMetods<A, M>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+        int8id: true;
+        methods: M;
+    }): Ancestor<A, string, T>;
+    model<A extends AttributesDefinition, K extends keyof A, M extends Methods<T>, N extends K extends keyof A ? Native<A[K]> : never, T extends Entry & ModelWithMetods<A, M>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+        methods: M;
+        primaryKey: K;
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, M extends Methods<T>, P extends Meta<Natural, Entry>, N extends P extends Meta<infer N, Entry> ? N : never, T extends Parent<P> & ModelWithMetods<A, M>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+        methods: M;
+        parent: P;
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
+        id?: number;
+    } & ModelWithMetods<A, M>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
+        methods: M;
+    }): Ancestor<A, number, T>;
+    model<A extends AttributesDefinition, T extends Entry & {
         id?: string;
-    } & Model<F, M>>(name: string, fields: F, options?: Options<M, T> & {
+    } & Model<A>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
         int8id: true;
-    }): Ancestor<F, string, T>;
-    model<F extends FieldsDefinition, K extends keyof F, M extends Methods<T>, N extends K extends keyof F ? Native<F[K]> : never, T extends Record & Model<F, M>>(name: string, fields: F, options?: Options<M, T> & {
+    }): Ancestor<A, string, T>;
+    model<A extends AttributesDefinition, K extends keyof A, N extends K extends keyof A ? Native<A[K]> : never, T extends Entry & Model<A>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
         primaryKey: K;
-    }): Ancestor<F, N, T>;
-    model<F extends FieldsDefinition, M extends Methods<T>, P extends Meta<unknown, Record>, N extends P extends Meta<infer N, Record> ? N : never, T extends Parent<P> & Model<F, M>>(name: string, fields: F, options?: Options<M, T> & {
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, P extends Meta<Natural, Entry>, N extends P extends Meta<infer N, Entry> ? N : never, T extends Parent<P> & Model<A>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
         parent: P;
-    }): Ancestor<F, N, T>;
-    model<F extends FieldsDefinition, M extends Methods<T>, T extends Record & {
+    }): Ancestor<A, N, T>;
+    model<A extends AttributesDefinition, T extends Entry & {
         id?: number;
-    } & Model<F, M>>(name: string, fields: F, options?: Options<M, T>): Ancestor<F, number, T>;
+    } & Model<A>>(name: string, attributes: A, options?: BaseModelOptions<T>): Ancestor<A, number, T>;
     checkSize(size: number, message: string): number;
 }
 export declare const Package: typeof Sedentary;
-export {};

package/index.js

@@ -1,33 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.Sedentary = void 0;
+exports.Package = exports.Sedentary = exports.Type = exports.Entry = void 0;
 const db_1 = require("./lib/db");
+const log_1 = require("./lib/log");
 const minidb_1 = require("./lib/minidb");
+var db_2 = require("./lib/db");
+Object.defineProperty(exports, "Entry", { enumerable: true, get: function () { return db_2.Entry; } });
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return db_2.Type; } });
 const allowedOption = ["indexes", "init", "int8id", "methods", "parent", "primaryKey", "sync", "tableName", "type"];
+const reservedNames = [
+    ...["attributeName", "base", "class", "constructor", "defaultValue", "entry", "fieldName", "init", "isModel"],
+    ...["load", "meta", "methods", "name", "primaryKey", "prototype", "save", "size", "tableName", "type"]
+];
 class Sedentary {
     constructor(filename, options) {
         this.sync = true;
         this.models = {};
         if (typeof filename !== "string")
-            throw new Error("Sedentary.constructor: 'filename' argument: Wrong type, expected 'string'");
+            throw new Error("new Sedentary: 'filename' argument: Wrong type, expected 'string'");
         if (!options)
             options = {};
         if (!(options instanceof Object))
-            throw new Error("Sedentary.constructor: 'options' argument: Wrong type, expected 'Object'");
-        for (const k in options) {
-            if (["log", "sync"].indexOf(k) === -1)
-                throw new Error(`Sedentary.constructor: 'options' argument: Unknown '${k}' option`);
-            this[k] = options[k];
-        }
-        // eslint-disable-next-line no-console
-        this.log || (this.log = console.log);
+            throw new Error("new Sedentary: 'options' argument: Wrong type, expected 'Object'");
+        for (const k in options)
+            if (!["log", "sync"].includes(k))
+                throw new Error(`new Sedentary: 'options' argument: Unknown '${k}' option`);
+        const { log, sync } = Object.assign({ sync: true }, options);
+        if (log !== null && log !== undefined && !(log instanceof Function))
+            throw new Error("new Sedentary: 'log' option: Wrong type, expected 'null' or 'Function'");
+        if (typeof sync !== "boolean")
+            throw new Error("new Sedentary: 'sync' option: Wrong type, expected 'boolean'");
+        this.log = (0, log_1.createLogger)(log);
         this.db = new minidb_1.MiniDB(filename, this.log);
+        this.sync = sync;
     }
     DATETIME() {
         return new db_1.Type({ base: Date, type: "DATETIME" });
     }
-    FKEY(record) {
-        return new db_1.Type({ base: record.base, size: 0, type: "" });
+    FKEY(attribute) {
+        const { attributeName, base, fieldName, size, tableName, type } = attribute;
+        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, tableName }, size, type });
     }
     INT(size) {
         const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
@@ -49,11 +61,11 @@ class Sedentary {
             this.log("Connecting...");
             await this.db.connect();
             this.log("Connected, syncing...");
-            await this.db.sync();
+            await this.db.syncDataBase();
             this.log("Synced");
         }
         catch (e) {
-            this.log("Connecting: " + e.message);
+            this.log("Connecting:", e.message);
             throw e;
         }
     }
@@ -62,21 +74,21 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    model(name, fields, options) {
+    model(name, attributes, options) {
         if (typeof name !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
         if (this.models[name])
             throw new Error(`Sedentary.model: '${name}' model: Model already defined`);
-        if (!fields)
-            fields = {};
-        if (!(fields instanceof Object))
-            throw new Error(`Sedentary.model: '${name}' model: 'fields' argument: Wrong type, expected 'Object'`);
+        if (!attributes)
+            attributes = {};
+        if (!(attributes instanceof Object))
+            throw new Error(`Sedentary.model: '${name}' model: 'attributes' argument: Wrong type, expected 'Object'`);
         if (!options)
             options = {};
         if (!(options instanceof Object))
             throw new Error(`Sedentary.model: '${name}' model: 'options' argument: Wrong type, expected 'Object'`);
         for (const k in options)
-            if (allowedOption.indexOf(k) === -1)
+            if (!allowedOption.includes(k))
                 throw new Error(`Sedentary.model: '${name}' model: 'options' argument: Unknown '${k}' option`);
         if (options.int8id && options.parent)
             throw new Error(`Sedentary.model: '${name}' model: 'int8id' and 'parent' options conflict each other`);
@@ -84,14 +96,15 @@ class Sedentary {
             throw new Error(`Sedentary.model: '${name}' model: 'int8id' and 'primaryKey' options conflict each other`);
         if (options.parent && options.primaryKey)
             throw new Error(`Sedentary.model: '${name}' model: 'parent' and 'primaryKey' options conflict each other`);
-        const constraints = [];
-        const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: name + "s" }, options);
+        let autoIncrement = true;
+        const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: name }, options);
         let { methods } = options;
+        let aarray = int8id
+            ? [new db_1.Attribute(Object.assign(Object.assign({}, this.INT8()), { attributeName: "id", fieldName: "id", notNull: true, tableName, unique: true }))]
+            : [new db_1.Attribute(Object.assign(Object.assign({}, this.INT(4)), { attributeName: "id", fieldName: "id", notNull: true, tableName, unique: true }))];
+        let constraints = [{ attribute: aarray[0], constraintName: `${tableName}_id_unique`, type: "u" }];
         const iarray = [];
-        const pkName = primaryKey || "id";
-        let farray = int8id
-            ? [new db_1.Field({ fieldName: "id", notNull: true, size: 8, type: "INT8", unique: true })]
-            : [new db_1.Field({ fieldName: "id", notNull: true, size: 4, type: "INT", unique: true })];
+        const pk = aarray[0];
         if (methods && !(methods instanceof Object))
             throw new Error(`Sedentary.model: '${name}' model: 'methods' option: Wrong type, expected 'Object'`);
         if (parent) {
@@ -106,119 +119,127 @@ class Sedentary {
         }
         if (primaryKey && typeof primaryKey !== "string")
             throw new Error(`Sedentary.model: '${name}' model: 'primaryKey' option: Wrong type, expected 'string'`);
-        if (primaryKey && Object.keys(fields).indexOf(primaryKey) === -1)
-            throw new Error(`Sedentary.model: '${name}' model: 'primaryKey' option: Field '${primaryKey}' does not exists`);
-        if (parent || primaryKey)
-            farray = [];
-        if (!parent)
-            iarray.push({ fields: [pkName], name: `${tableName}_${pkName}_unique`, type: "btree", unique: true });
-        for (const fname in fields) {
-            if (["base", "constructor", "load", "meta", "name", "prototype", "save", "size", "type"].indexOf(fname) !== -1)
-                throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: Reserved name`);
-            const field = fields[fname];
-            // eslint-disable-next-line prefer-const
-            let { defaultValue, fieldName, notNull, size, type, unique } = (() => {
+        if (primaryKey && !Object.keys(attributes).includes(primaryKey))
+            throw new Error(`Sedentary.model: '${name}' model: 'primaryKey' option: Attribute '${primaryKey}' does not exists`);
+        if (parent || primaryKey) {
+            autoIncrement = false;
+            aarray = [];
+            constraints = [];
+        }
+        for (const attributeName in attributes) {
+            if (reservedNames.includes(attributeName))
+                throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: Reserved name`);
+            const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
+                if (func === this.FKEY)
+                    throw new Error(`${message1} 'this.FKEY' can't be used directly`);
+                if (func !== this.DATETIME && func !== this.INT && func !== this.INT8 && func !== this.VARCHAR)
+                    throw new Error(`${message1} ${message2}`);
+                return new db_1.Attribute(Object.assign({ attributeName, defaultValue, fieldName, notNull, tableName, unique }, func()));
+            };
+            const attributeDefinition = attributes[attributeName];
+            let { base, defaultValue, fieldName, foreignKey, notNull, size, type, unique } = (() => {
                 const ret = (() => {
-                    // eslint-disable-next-line prefer-const
-                    let { defaultValue, fieldName, notNull, unique, type } = { defaultValue: undefined, fieldName: fname, notNull: false, unique: false, type: null };
-                    const call = (defaultValue, fieldName, notNull, unique, func, message) => {
-                        if (func !== this.DATETIME && func !== this.FKEY && func !== this.INT && func !== this.INT8 && func !== this.VARCHAR)
-                            throw new Error(message);
-                        return new db_1.Field(Object.assign({ defaultValue, fieldName, notNull, unique }, func()));
-                    };
-                    if (field instanceof db_1.Type)
-                        return new db_1.Field(Object.assign({ fieldName: fname }, Object.assign({ notNull: false }, field)));
-                    if (field instanceof Function)
-                        return call(undefined, fname, false, false, field, `Sedentary.model: '${name}' model: '${fname}' field: Wrong type, expected 'Field'`);
-                    if (!(field instanceof Object))
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: Wrong field type, expected 'Field'`);
-                    ({ defaultValue, fieldName, notNull, unique, type } = Object.assign({ notNull: false }, field));
-                    if (!fieldName)
-                        fieldName = fname;
+                    if (attributeDefinition instanceof db_1.Type)
+                        return new db_1.Attribute(Object.assign({ attributeName, fieldName: attributeName, notNull: false, tableName }, attributeDefinition));
+                    if (attributeDefinition instanceof Function)
+                        return call(undefined, attributeName, false, false, attributeDefinition, `Sedentary.model: '${name}' model: '${attributeName}' attribute:`, "Wrong type, expected 'Attribute'");
+                    if (!(attributeDefinition instanceof Object))
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: Wrong attribute type, expected 'Attribute'`);
+                    const attributeDefaults = Object.assign({ defaultValue: undefined, fieldName: attributeName, notNull: false, unique: false }, attributeDefinition);
+                    const { defaultValue, fieldName, notNull, unique, type } = attributeDefaults;
                     if (defaultValue === null)
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'defaultValue' option: Does 'null' default value really makes sense?`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'defaultValue' option: Does 'null' default value really makes sense?`);
                     if (typeof fieldName !== "string")
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'fieldName' option: Wrong type, expected 'string'`);
-                    if (!type)
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: Missing 'type' option`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'fieldName' option: Wrong type, expected 'string'`);
+                    if (typeof notNull !== "boolean")
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'notNull' option: Wrong type, expected 'boolean'`);
+                    if (typeof unique !== "boolean")
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'unique' option: Wrong type, expected 'boolean'`);
+                    if (type === undefined)
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: Missing 'type' option`);
                     if (type instanceof db_1.Type)
-                        return new db_1.Field(Object.assign(Object.assign(Object.assign({}, Object.assign({ notNull: false }, field)), { fieldName }), type));
+                        return new db_1.Attribute(Object.assign({ attributeName, defaultValue, fieldName, notNull, tableName, unique }, type));
                     if (type instanceof Function)
-                        return call(defaultValue, fieldName, notNull, unique, type, `Sedentary.model: '${name}' model: '${fname}' field: 'type' option: Wrong type, expected 'Type'`);
-                    throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'type' option: Wrong type, expected 'Type'`);
+                        return call(defaultValue, fieldName, notNull, unique, type, `Sedentary.model: '${name}' model: '${attributeName}' attribute: 'type' option:`, "Wrong type, expected 'Type'");
+                    throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'type' option: Wrong type, expected 'Type'`);
                 })();
                 const { base, defaultValue } = ret;
                 if (defaultValue !== undefined) {
+                    if (base === Date && !(defaultValue instanceof Date))
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'Date'`);
                     if (base === Number && typeof defaultValue !== "number")
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'defaultValue' option: Wrong type, expected 'number'`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'number'`);
                     if (base === String && typeof defaultValue !== "string")
-                        throw new Error(`Sedentary.model: '${name}' model: '${fname}' field: 'defaultValue' option: Wrong type, expected 'string'`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${attributeName}' attribute: 'defaultValue' option: Wrong type, expected 'string'`);
                 }
                 return ret;
             })();
-            if (primaryKey === fname) {
+            if (primaryKey === attributeName) {
                 notNull = true;
                 unique = true;
             }
             if (defaultValue)
                 notNull = true;
-            farray.push(new db_1.Field({ defaultValue, fieldName, notNull, size, type, unique }));
-            if (unique && fname !== pkName)
-                iarray.push({ fields: [fieldName], name: `${tableName}_${fieldName}_unique`, type: "btree", unique: true });
+            const attribute = new db_1.Attribute({ attributeName, base, defaultValue, fieldName, foreignKey, notNull, size, tableName, type, unique });
+            aarray.push(attribute);
+            if (foreignKey)
+                constraints.push({ attribute, constraintName: `fkey_${fieldName}_${foreignKey.tableName}_${foreignKey.fieldName}`, type: "f" });
+            if (unique)
+                constraints.push({ attribute, constraintName: `${tableName}_${fieldName}_unique`, type: "u" });
         }
         if (indexes) {
-            const flds = fields;
+            const flds = attributes;
             if (!(indexes instanceof Object))
                 throw new Error(`Sedentary.model: '${name}' model: 'indexes' option: Wrong type, expected 'Object'`);
-            for (const iname in indexes) {
-                if (iarray.filter(_ => _.name === iname).length !== 0)
-                    throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: index name already inferred by the unique constraint on a field`);
-                const idx = indexes[iname];
-                const checkField = (field, l) => {
-                    if (typeof field !== "string")
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: #${l} field: Wrong type, expected 'string'`);
-                    if (!(field in flds))
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: #${l} field: Unknown field '${field}'`);
+            for (const indexName in indexes) {
+                if (aarray.filter(({ fieldName, unique }) => unique && `${tableName}_${fieldName}_unique` === indexName).length !== 0)
+                    throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: index name already inferred by the unique constraint on an attribute`);
+                const idx = indexes[indexName];
+                const checkAttribute = (attribute, l) => {
+                    if (typeof attribute !== "string")
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: #${l + 1} attribute: Wrong type, expected 'string'`);
+                    if (!(attribute in flds))
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: #${l + 1} attribute: Unknown attribute '${attribute}'`);
                 };
-                let fields;
+                let attributes;
                 let type = "btree";
                 let unique = false;
                 if (idx instanceof Array) {
-                    idx.forEach(checkField);
-                    fields = idx;
+                    idx.forEach(checkAttribute);
+                    attributes = idx;
                 }
                 else if (typeof idx === "string") {
-                    checkField(idx, 0);
-                    fields = [idx];
+                    checkAttribute(idx, 0);
+                    attributes = [idx];
                 }
                 else if (idx instanceof Object) {
                     for (const k in idx)
-                        if (["fields", "type", "unique"].indexOf(k) === -1)
-                            throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: Unknown index option '${k}'`);
-                    ({ fields, type, unique } = Object.assign({ type: "btree", unique: false }, idx));
-                    if (!fields)
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: Missing 'fields' option`);
-                    if (fields instanceof Array)
-                        fields.forEach(checkField);
-                    else if (typeof fields === "string") {
-                        checkField(fields, 0);
-                        fields = [fields];
+                        if (!["attributes", "type", "unique"].includes(k))
+                            throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: Unknown index option '${k}'`);
+                    ({ attributes, type, unique } = Object.assign({ type: "btree", unique: false }, idx));
+                    if (!attributes)
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: Missing 'attributes' option`);
+                    if (attributes instanceof Array)
+                        attributes.forEach(checkAttribute);
+                    else if (typeof attributes === "string") {
+                        checkAttribute(attributes, 0);
+                        attributes = [attributes];
                     }
                     else
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: 'fields' option: Wrong type, expected 'FieldNames'`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'attributes' option: Wrong type, expected 'FieldNames'`);
                     if (typeof type !== "string")
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: 'type' option: Wrong type, expected 'string'`);
-                    if (["btree", "hash"].indexOf(type) === -1)
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: 'type' option: Wrong value, expected 'btree' or 'hash'`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'type' option: Wrong type, expected 'string'`);
+                    if (!["btree", "hash"].includes(type))
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'type' option: Wrong value, expected 'btree' or 'hash'`);
                     if (typeof unique !== "boolean")
-                        throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: 'unique' option: Wrong type, expected 'boolean'`);
+                        throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: 'unique' option: Wrong type, expected 'boolean'`);
                 }
                 else
-                    throw new Error(`Sedentary.model: '${name}' model: '${iname}' index: Wrong type, expected 'Object'`);
-                iarray.push({ fields, name: iname, type, unique });
+                    throw new Error(`Sedentary.model: '${name}' model: '${indexName}' index: Wrong type, expected 'Object'`);
+                iarray.push({ fields: attributes, indexName, type, unique });
             }
         }
-        this.db.addTable(new db_1.Table({ constraints, fields: farray, indexes: iarray, parent, primaryKey, sync, tableName }));
+        this.db.tables.push(new db_1.Table({ autoIncrement, constraints, attributes: aarray, indexes: iarray, parent, sync, tableName }));
         this.models[name] = true;
         const init = parent
             ? options.init
@@ -229,7 +250,7 @@ class Sedentary {
                 : parent.init
             : options.init;
         const flds = {};
-        for (const key in fields)
+        for (const key in attributes)
             flds[key] = null;
         class Class {
             constructor() {
@@ -249,15 +270,19 @@ class Sedentary {
                 return resolve([new Class()]);
             reject(new Error("boh"));
         }, 10));
-        Object.defineProperty(load, "name", { value: name + "s.load" });
-        const meta = { tableName, primaryKey, init, methods };
-        Object.defineProperty(Class, "name", { value: name });
+        Object.defineProperty(load, "name", { value: name + ".load" });
+        const meta = { base: Number, type: "meta", tableName, primaryKey, init, methods };
+        Object.defineProperty(Class, "isModel", { value: () => true });
         Object.defineProperty(Class, "load", { value: load });
         Object.defineProperty(Class, "meta", { value: new db_1.Meta(meta) });
+        Object.defineProperty(Class, "name", { value: name });
         Object.defineProperty(Class.prototype.save, "name", { value: name + ".save" });
         Object.assign(Class, new db_1.Meta(meta));
-        Object.assign(Class, Object.assign(Object.assign({}, fields), { isModel: () => true }));
         Object.assign(Class.prototype, methods);
+        for (const attribute of aarray)
+            Object.defineProperty(Class, attribute.attributeName, { value: attribute });
+        for (const key of ["attributeName", "base", "fieldName", "size", "type", "unique"])
+            Object.defineProperty(Class, key, { value: pk[key] });
         return Class;
     }
     checkSize(size, message) {
@@ -271,12 +296,11 @@ class Sedentary {
 exports.Sedentary = Sedentary;
 exports.Package = Sedentary;
 const db = new Sedentary("gino");
-const Users = db.model("User", { foo: db.INT(), bar: db.VARCHAR() }, {});
-const fields = {
+const Users = db.model("User", { foo: db.INT(), bar: { type: db.VARCHAR(), unique: true } }, {});
+class Item extends db.model("Item", {
     num: db.FKEY(Users),
     str: db.VARCHAR()
-};
-class Item extends db.model("Item", fields, {
+}, {
     init: function () {
         this.num = 0;
         this.str = "0";
@@ -309,7 +333,7 @@ class Next extends db.model("Next", { a: db.INT, b: db.INT }, {
     primaryKey: "a"
 }) {
 }
-class Current extends db.model("Current", { b: db.FKEY(Next) }, {
+class Current extends db.model("Current", { b: { type: db.FKEY(Next), unique: true } }, {
     init: function () {
         this.b = 24;
     }

package/lib/db.d.ts

@@ -1,89 +1,80 @@
-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;
     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 declare type IndexFields = string[] | string;
-export interface IndexDef {
+export interface Index {
     fields: string[];
-    name: string;
+    indexName: string;
     type: "btree" | "hash";
     unique: boolean;
 }
-interface IndexOptions {
-    fields: IndexFields;
-    type?: "btree" | "hash";
-    unique?: boolean;
-}
-export declare type Index = IndexFields | IndexOptions;
 interface ITable {
+    attributes: Attribute<Natural, unknown>[];
+    autoIncrement: boolean;
     constraints: Constraint[];
-    fields: Field<unknown, unknown>[];
-    indexes: IndexDef[];
-    oid?: number;
-    parent: Meta<unknown, Record>;
-    primaryKey: string;
+    indexes: Index[];
+    parent: Meta<Natural, unknown>;
     sync: boolean;
     tableName: string;
 }
 declare const Table_base: new (defaults?: ITable) => ITable;
 export declare class Table extends Table_base {
-    autoIncrement: boolean;
-    autoIncrementOwn: boolean;
-    constructor(defaults: ITable);
+    autoIncrementOwn?: boolean;
+    oid?: number;
+    findField(name: string): Attribute<Natural, unknown>;
 }
 export declare abstract class DB {
-    tables: {
-        [key: string]: Table;
-    };
-    tablesArr: Table[];
-    protected log: (message: string) => void;
+    tables: Table[];
+    protected log: (...data: unknown[]) => void;
+    protected sync: boolean;
     abstract connect(): Promise<void>;
     abstract end(): Promise<void>;
     constructor(log: (message: string) => void);
-    addTable(table: Table): void;
-    protected indexesEq(a: IndexDef, b: IndexDef): boolean;
-    sync(): Promise<void>;
-    abstract dropConstraints(table: Table): Promise<void>;
+    findTable(name: string): Table;
+    protected indexesEq(a: Index, b: Index): boolean;
+    syncDataBase(): Promise<void>;
+    protected syncLog(...data: unknown[]): 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>;

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) {
@@ -38,28 +34,18 @@ function autoImplement() {
     };
 }
 class Table extends autoImplement() {
-    constructor(defaults) {
-        super(defaults);
-        if (!this.primaryKey) {
-            if (this.parent)
-                this.primaryKey = this.parent.primaryKey;
-            else {
-                this.primaryKey = "id";
-                this.autoIncrement = true;
-            }
-        }
+    findField(name) {
+        return this.attributes.filter(_ => _.fieldName === name)[0];
     }
 }
 exports.Table = Table;
 class DB {
     constructor(log) {
-        this.tables = {};
-        this.tablesArr = [];
+        this.tables = [];
         this.log = log;
     }
-    addTable(table) {
-        this.tables[table.tableName] = table;
-        this.tablesArr.push(table);
+    findTable(name) {
+        return this.tables.filter(_ => _.tableName === name)[0];
     }
     indexesEq(a, b) {
         if (a.fields.length !== b.fields.length)
@@ -73,12 +59,12 @@ class DB {
             return false;
         return true;
     }
-    async sync() {
-        for (const i in this.tablesArr) {
-            const table = this.tablesArr[i];
+    async syncDataBase() {
+        for (const table of this.tables) {
+            this.sync = table.sync;
             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);
@@ -86,5 +72,9 @@ class DB {
             await this.syncIndexes(table);
         }
     }
+    syncLog(...data) {
+        const args = this.sync ? data : ["NOT SYNCING:", ...data];
+        this.log(...args);
+    }
 }
 exports.DB = DB;

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,9 +4,9 @@ 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>;

package/lib/minidb.js

@@ -22,28 +22,36 @@ 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.findField(attribute)) {
+                this.log(`'${table.tableName}': Removing field: '${attribute}'`);
+                delete fields[attribute];
             }
         }
         await this.save();
     }
-    async dropIndexes(table) {
+    // 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(_ => _.name === name);
+            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];
@@ -57,11 +65,20 @@ class MiniDB extends db_1.DB {
     }
     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();
@@ -69,50 +86,50 @@ class MiniDB extends db_1.DB {
     async syncIndexes(table) {
         const { indexes } = this.body.tables[table.tableName];
         for (const index of table.indexes) {
-            const { name } = index;
-            if (!(name in indexes)) {
-                this.log(`'${table.tableName}': Adding index: '${name}' on (${index.fields.map(_ => `'${_}'`).join(", ")}) type '${index.type}'${index.unique ? " unique" : ""}`);
-                indexes[name] = index;
+            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 field of table.fields) {
+        for (const attribute of table.attributes) {
             const { fields } = this.body.tables[table.tableName];
-            const { defaultValue, fieldName, notNull, size, type } = field;
-            let dbField = fields[fieldName];
-            if (!dbField) {
+            const { defaultValue, fieldName, notNull, size, type } = attribute;
+            let field = fields[fieldName];
+            if (!field) {
                 this.log(`'${table.tableName}': Adding field: '${fieldName}' '${type}' '${size || ""}'`);
-                dbField = fields[fieldName] = { size, type };
+                field = fields[fieldName] = { size, type };
             }
-            if (dbField.size !== size || dbField.type !== type) {
+            if (field.size !== size || field.type !== type) {
                 this.log(`'${table.tableName}': Changing field type: '${fieldName}' '${type}' '${size || ""}'`);
-                dbField = fields[fieldName] = Object.assign(Object.assign({}, dbField), { size, type });
+                field = fields[fieldName] = Object.assign(Object.assign({}, field), { size, type });
             }
-            if (dbField.default) {
+            if (field.default) {
                 if (!defaultValue) {
                     this.log(`'${table.tableName}': Dropping default value for field: '${fieldName}'`);
-                    delete dbField.default;
+                    delete field.default;
                 }
-                else if (dbField.default !== defaultValue) {
+                else if (field.default !== defaultValue) {
                     this.log(`'${table.tableName}': Changing default value to '${defaultValue}' for field: '${fieldName}'`);
-                    dbField.default = defaultValue;
+                    field.default = defaultValue;
                 }
             }
             else if (defaultValue) {
-                this.log(`'${table.tableName}': Setting default value '${defaultValue}' for field: '${fieldName}'`);
-                dbField.default = defaultValue;
+                this.log(`'${table.tableName}': Setting default value '${defaultValue instanceof Date ? defaultValue.toISOString() : defaultValue}' for field: '${fieldName}'`);
+                field.default = defaultValue;
             }
-            if (dbField.notNull) {
+            if (field.notNull) {
                 if (!notNull) {
                     this.log(`'${table.tableName}': Dropping not null for field: '${fieldName}'`);
-                    delete dbField.notNull;
+                    delete field.notNull;
                 }
             }
             else if (notNull) {
                 this.log(`'${table.tableName}': Setting not null for field: '${fieldName}'`);
-                dbField.notNull = true;
+                field.notNull = true;
             }
         }
         await this.save();

package/package.json

@@ -5,21 +5,24 @@
   "description": "The ORM which never needs to migrate",
   "devDependencies": {
     "@types/mocha": "9.0.0",
-    "@types/node": "16.11.6",
+    "@types/node": "16.11.10",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.3.0",
-    "@typescript-eslint/parser": "5.3.0",
-    "eslint": "8.2.0",
+    "@typescript-eslint/eslint-plugin": "5.4.0",
+    "@typescript-eslint/parser": "5.4.0",
+    "eslint": "8.3.0",
     "mocha": "9.1.3",
     "nyc": "15.1.0",
-    "prettier": "2.4.1",
+    "prettier": "2.5.0",
     "ts-node": "10.4.0",
-    "typescript": "4.4.4",
+    "typescript": "4.5.2",
     "yamljs": "0.3.0"
   },
   "engines": {
     "node": ">=12.0"
   },
+  "funding": {
+    "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
+  },
   "homepage": "https://github.com/iccicci/sedentary#readme",
   "keywords": [
     "DB",
@@ -53,5 +56,5 @@
     "version": "node -r ts-node/register utils.ts version"
   },
   "types": "index.d.ts",
-  "version": "0.0.12"
+  "version": "0.0.16"
 }

package/requirements.txt

@@ -0,0 +1,2 @@
+sphinx
+sphinx_rtd_theme

package/tmp.js

@@ -1,123 +0,0 @@
-/* eslint-disable no-console */
-
-// The account we use to store followings
-const followingsUID = 3186068;
-// Gather the loggedUID from window.localStorage
-const { loggedUID } = window.localStorage;
-// Gather the CSRF-Token from the cookies
-const csrf = document.cookie.split("; ").reduce((ret, _) => (_.startsWith("session_key=") ? _.substr(12) : ret), null);
-
-// APIs could have errors, let's do some retries
-async function myFetch(url, options, attempt = 0) {
-  try {
-    const res = await fetch("https://booyah.live/api/v3/" + url, options);
-    const ret = await res.json();
-
-    return ret;
-  } catch(e) {
-    // After too many consecutive errors, let's abort: we need to retry later
-    if(attempt === 3) throw e;
-
-    return myFetch(url, option, attempt + 1);
-  }
-}
-
-function expire(uid, add = true) {
-  const { followingsExpire } = window.localStorage;
-  let expires = {};
-
-  try {
-    // Get and parse followingsExpire from localStorage
-    expires = JSON.parse(followingsExpire);
-  } catch(e) {
-    // In case of error (ex. new browsers) simply init to empty
-    window.localStorage.followingsExpire = "{}";
-  }
-
-  if(! uid) return expires;
-
-  // Set expire after 1 day
-  if(add) expires[uid] = new Date().getTime() + 3600 * 24 * 1000;
-  else delete expires[uid];
-
-  window.localStorage.followingsExpire = JSON.stringify(expires);
-}
-
-async function clean() {
-  try {
-    const expires = expire();
-    const now = new Date().getTime();
-
-    for(const uid in expires) {
-      if(expires[uid] < now) {
-        await followUser(parseInt(uid), false);
-        expire(uid, false);
-      }
-    }
-  } catch(e) {}
-
-  // Repeat clean in an hour
-  window.setTimeout(clean, 3600 * 1000);
-}
-
-async function fetchFollow(uid, type = "followers", from = 0) {
-  const { cursor, follower_list, following_list } = await myFetch(`users/${uid}/${type}?cursor=${from}&count=50`);
-  const got = (type === "followers" ? follower_list : following_list).map(_ => _.uid);
-  const others = cursor ? await fetchFollow(uid, type, cursor) : [];
-
-  return [...got, ...others];
-}
-
-async function followUser(uid, follow = true) {
-  console.log(`${follow ? "F" : "Unf"}ollowing ${uid}...`);
-  return myFetch(`users/${loggedUID}/followings`, {
-    method:  follow ? "POST" : "DELETE",
-    headers: { "X-CSRF-Token": csrf },
-    body:    JSON.stringify({ followee_uid: uid, source: 43 })
-  });
-}
-
-async function doAll() {
-  if(! loggedUID) throw new Error("Can't get 'loggedUID' from localStorage: try to login again");
-  if(! csrf) throw new Error("Can't get session token from cookies: try to login again");
-
-  console.log("Fetching current followings...");
-  const currentFollowings = await fetchFollow(loggedUID, "followings");
-
-  console.log("Fetching permanent followings...");
-  const permanentFollowings = await fetchFollow(followingsUID, "followings");
-
-  console.log("Syncing permanent followings...");
-  for(const uid of permanentFollowings) {
-    expire(uid, false);
-
-    if(currentFollowings.indexOf(uid) === -1) {
-      await followUser(uid);
-      currentFollowings.push(uid);
-    }
-  }
-
-  // Sync followingsExpire in localStorage
-  for(const uid of currentFollowings) if(permanentFollowings.indexOf(uid) === -1) expire(uid);
-  // Call first clean task in 5 minutes
-  window.setTimeout(clean, 300 * 1000);
-
-  // Gather uid from window.location
-  const match = /\/studio\/(\d+)/.exec(window.location.pathname);
-
-  if(match) {
-    console.log("Fetching this user followers...");
-    const followings = await fetchFollow(parseInt(match[1]));
-
-    for(const uid of followings) {
-      if(currentFollowings.indexOf(uid) === -1) {
-        await followUser(uid);
-        expire(uid);
-      }
-    }
-  }
-
-  return "Done";
-}
-
-await doAll();