sedentary 0.0.17 → 0.0.18

package/index.d.ts

@@ -1,5 +1,5 @@
-import { DB, Entry, Meta, Natural, Type } from "./lib/db";
-export { Entry, Natural, Type } from "./lib/db";
+import { DB, Entry, ForeignKeyOptions, Meta, Natural, Type } from "./lib/db";
+export { Entry, ForeignKeyActions, ForeignKeyOptions, 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;
@@ -73,7 +73,7 @@ export declare class Sedentary {
     private models;
     constructor(filename: string, options?: SedentaryOptions);
     DATETIME(): Type<Date, unknown>;
-    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>): Type<N, E>;
+    FKEY<N extends Natural, E extends Entry>(attribute: Type<N, E>, options?: ForeignKeyOptions): Type<N, E>;
     INT(size?: number): Type<number, unknown>;
     INT8(): Type<string, unknown>;
     VARCHAR(size?: number): Type<string, unknown>;

package/index.js

@@ -37,9 +37,9 @@ class Sedentary {
     DATETIME() {
         return new db_1.Type({ base: Date, type: "DATETIME" });
     }
-    FKEY(attribute) {
+    FKEY(attribute, options) {
         const { attributeName, base, fieldName, size, tableName, type } = attribute;
-        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, tableName }, size, type });
+        return new db_1.Type({ base, foreignKey: { attributeName, fieldName, options, tableName }, size, type });
     }
     INT(size) {
         const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
@@ -107,6 +107,7 @@ class Sedentary {
         const pk = aarray[0];
         if (methods && !(methods instanceof Object))
             throw new Error(`Sedentary.model: '${modelName}' model: 'methods' option: Wrong type, expected 'Object'`);
+        const originalMethods = methods;
         if (parent) {
             try {
                 if (!parent.isModel())
@@ -174,6 +175,23 @@ class Sedentary {
                 }
                 return ret;
             })();
+            if (foreignKey) {
+                if (!foreignKey.options)
+                    foreignKey.options = {};
+                if (!(foreignKey.options instanceof Object))
+                    throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Wrong options type, expected 'Object'`);
+                for (const k in foreignKey.options)
+                    if (!["onDelete", "onUpdate"].includes(k))
+                        throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: Unknown option '${k}'`);
+                for (const onChange of ["onDelete", "onUpdate"]) {
+                    const actions = ["cascade", "no action", "restrict", "set default", "set null"];
+                    let action = foreignKey.options[onChange];
+                    if (!action)
+                        action = foreignKey.options[onChange] = "no action";
+                    if (action && !actions.includes(action))
+                        throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: '${onChange}' option: Wrong value, expected ${actions.map(_ => `'${_}'`).join(" | ")}`);
+                }
+            }
             if (primaryKey === attributeName) {
                 notNull = true;
                 unique = true;
@@ -249,9 +267,6 @@ class Sedentary {
                 }
                 : parent.init
             : options.init;
-        const flds = {};
-        for (const key in attributes)
-            flds[key] = null;
         class Class {
             constructor() {
                 if (init)
@@ -271,13 +286,65 @@ class Sedentary {
             reject(new Error("boh"));
         }, 10));
         Object.defineProperty(load, "name", { value: modelName + ".load" });
-        const meta = { base: Number, type: "meta", tableName, primaryKey, init, methods };
+        const metaAttributes = aarray.reduce((ret, curr) => {
+            ret[curr.attributeName] = curr;
+            return ret;
+        }, {});
+        const metaForeignKeys = aarray
+            .filter(_ => _.foreignKey)
+            .reduce((ret, curr) => {
+            ret[curr.attributeName] = curr;
+            return ret;
+        }, {});
+        const meta = new db_1.Meta({ base: Number, attributes: metaAttributes, foreignKeys: metaForeignKeys, modelName, parent: parent, type: "meta", tableName, primaryKey, init, methods });
+        for (const foreignKey in metaForeignKeys) {
+            if (foreignKey + "Load" in metaAttributes)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute`);
+            if (originalMethods && foreignKey + "Load" in originalMethods)
+                throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method`);
+        }
+        if (originalMethods)
+            for (const method in originalMethods)
+                if (method in metaAttributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute`);
+        const checkParent = (parent) => {
+            if (!parent)
+                return;
+            for (const attribute in metaAttributes) {
+                if (attribute in parent.attributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an attribute of '${parent.modelName}' model`);
+                if (parent.methods && attribute in parent.methods)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with a method of '${parent.modelName}' model`);
+                for (const foreignKey in parent.foreignKeys)
+                    if (attribute === foreignKey + "Load")
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${attribute}' attribute: conflicts with an inferred methods of '${parent.modelName}' model`);
+            }
+            for (const foreignKey in metaForeignKeys) {
+                if (foreignKey + "Load" in parent.attributes)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with an attribute of '${parent.modelName}' model`);
+                if (parent.methods && foreignKey + "Load" in parent.methods)
+                    throw new Error(`Sedentary.model: '${modelName}' model: '${foreignKey}' attribute: '${foreignKey}Load' inferred methods conflicts with a method of '${parent.modelName}' model`);
+            }
+            if (originalMethods) {
+                for (const method in originalMethods) {
+                    if (method in parent.attributes)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an attribute of '${parent.modelName}' model`);
+                    for (const foreignKey in parent.foreignKeys)
+                        if (foreignKey + "Load" === method)
+                            throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with an inferred methods of '${parent.modelName}' model`);
+                    if (parent.methods && method in parent.methods)
+                        throw new Error(`Sedentary.model: '${modelName}' model: '${method}' method: conflicts with a method of '${parent.modelName}' model`);
+                }
+            }
+            checkParent(parent.parent);
+        };
+        checkParent(parent);
         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, "meta", { value: meta });
         Object.defineProperty(Class, "name", { value: modelName });
         Object.defineProperty(Class.prototype.save, "name", { value: modelName + ".save" });
-        Object.assign(Class, new db_1.Meta(meta));
+        Object.assign(Class, meta);
         Object.assign(Class.prototype, methods);
         for (const attribute of aarray)
             Object.defineProperty(Class, attribute.attributeName, { value: attribute });
@@ -340,9 +407,9 @@ class Current extends db.model("Current", { b: { type: db.FKEY(Next), unique: tr
     }
 }) {
 }
-class Last extends db.model("Last", { b: db.FKEY(Current.b) }, {
+class Last extends db.model("Last", { c: db.FKEY(Current.b) }, {
     init: function () {
-        this.b = 24;
+        this.c = 24;
     },
     parent: Next
 }) {
@@ -358,3 +425,29 @@ class Last extends db.model("Last", { b: db.FKEY(Current.b) }, {
     }
     return true;
 })();
+/*
+export let factory = () => {
+    class Foo {
+        a = 3;
+        b = 'bar'
+        c?: boolean
+    }
+    return Foo as (new () => { [key in keyof Foo]: Foo[key] })
+};
+
+export const FooConstr = factory()
+export type TypeExtractor<T> = T extends (new() => infer E) ? E : never;
+export type FooType = TypeExtractor<typeof FooConstr>;
+
+const foo = new FooConstr()
+
+function rino(a:FooType){
+    if(a instanceof FooConstr){console.log("sisi")}
+    if(a instanceof FooType){console.log("sisi")}
+}
+
+rino(foo);
+
+
+B.prototype instanceof A
+*/

package/lib/db.d.ts

@@ -3,6 +3,11 @@ export declare class Entry {
     init(): void;
     save(): Promise<boolean>;
 }
+export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
+export interface ForeignKeyOptions {
+    onDelete?: ForeignKeyActions;
+    onUpdate?: ForeignKeyActions;
+}
 export declare class Type<N extends Natural, E> {
     base: unknown;
     entry?: E;
@@ -12,16 +17,25 @@ export declare class Type<N extends Natural, E> {
     foreignKey?: {
         attributeName: string;
         fieldName: string;
+        options?: ForeignKeyOptions;
         tableName: string;
     };
     constructor(from: Type<N, E>);
 }
 export declare class Meta<N extends Natural, E> extends Type<N, E> {
+    attributes: {
+        [key: string]: unknown;
+    };
+    foreignKeys: {
+        [key: string]: unknown;
+    };
     init: () => void;
     isModel?: () => boolean;
     methods: {
         [key: string]: () => unknown;
     };
+    modelName: string;
+    parent?: Meta<Natural, E>;
     primaryKey: string;
     tableName: string;
     constructor(from: Meta<N, E>);

package/lib/minidb.js

@@ -23,7 +23,10 @@ class MiniDB extends db_1.DB {
     async dropConstraints(table) {
         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) {
+            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];
@@ -31,7 +34,7 @@ class MiniDB extends db_1.DB {
         }
         for (const constraint of Object.keys(constraints.u).sort()) {
             if (!table.constraints.filter(({ constraintName, type }) => constraintName === constraint && type === "u").length) {
-                this.syncLog(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].fieldName}'`);
+                this.syncLog(`'${table.tableName}': Removing unique constraint from field: '${constraints.u[constraint].on}'`);
                 if (this.sync)
                     delete constraints.u[constraint];
             }
@@ -70,20 +73,20 @@ class MiniDB extends db_1.DB {
     async syncConstraints(table) {
         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.syncLog(`'${table.tableName}': Adding foreign key '${constraint.constraintName}' on field: '${fieldName}' references '${foreignKey.tableName}(${foreignKey.fieldName})'`);
-                        if (this.sync)
-                            constraints[type][constraintName] = { fieldName, toField: foreignKey.fieldName, toTable: foreignKey.tableName };
-                        break;
-                    case "u":
-                        this.syncLog(`'${table.tableName}': Adding unique constraint on field: '${fieldName}'`);
-                        if (this.sync)
-                            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 };
                 }
             }
         }

package/package.json

@@ -56,5 +56,5 @@
     "version": "node -r ts-node/register utils.ts version"
   },
   "types": "index.d.ts",
-  "version": "0.0.17"
+  "version": "0.0.18"
 }