sedentary 0.0.18 → 0.0.19

package/index.d.ts

@@ -1,5 +1,5 @@
-import { DB, Entry, ForeignKeyOptions, Meta, Natural, Type } from "./lib/db";
-export { Entry, ForeignKeyActions, ForeignKeyOptions, Natural, Type } from "./lib/db";
+import { DB, EntryBase, ForeignKeyOptions, Meta, Natural, Type } from "./lib/db";
+export { EntryBase, 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;
@@ -12,12 +12,12 @@ export declare type AttributeDefinition<N extends Natural, E> = TypeDefinition<N
 export declare type AttributesDefinition = {
     [key: string]: AttributeDefinition<Natural, unknown>;
 };
-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 ForeignKeysAttributes<T, k> = T extends AttributeDefinition<Natural, infer E> ? (E extends EntryBase ? k : never) : never;
+declare type ForeignKeys<A extends AttributesDefinition> = {
+    [a in keyof A]?: ForeignKeysAttributes<A[a], a>;
+}[keyof A];
+declare type Methods<E> = {
+    [key: string]: (this: E) => unknown;
 };
 declare type Native__<T> = T extends Type<infer N, unknown> ? N : never;
 declare type Native_<T> = T extends () => Type<infer N, infer E> ? Native__<Type<N, E>> : Native__<T>;
@@ -33,34 +33,51 @@ export declare type IndexDefinition = IndexAttributes | IndexOptions;
 export declare type IndexesDefinition = {
     [key: string]: IndexDefinition;
 };
-declare type BaseModelOptions<T> = {
+declare type BaseModelOptions<B extends boolean, T> = {
     indexes?: IndexesDefinition;
     init?: (this: T) => void;
+    int8id?: B;
     sync?: boolean;
     tableName?: string;
 };
-export declare type ModelOptions<K extends string, M extends Methods<T>, P extends Meta<Natural, Entry>, T extends Entry> = BaseModelOptions<T> & {
-    int8id?: boolean;
+export declare type ModelOptions<B extends boolean, K extends string, M extends Methods<T>, P extends Meta<Natural, EntryBase>, T extends EntryBase> = BaseModelOptions<B, T> & {
     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]>;
-} & {
-    [a in Keys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
-} & M;
-declare type Model<A extends AttributesDefinition> = {
+declare type ModelBaseOptions = {
+    indexes?: IndexesDefinition;
+    sync?: boolean;
+    tableName?: string;
+};
+export declare type ModelOptions2 = ModelBaseOptions & {
+    int8id?: boolean;
+    parent?: Type<Natural, EntryBase>;
+    primaryKey?: string;
+};
+declare type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+declare type EntryIdNatural<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
+export declare type EntryId<B extends boolean> = {
+    id?: EntryIdNatural<B>;
+};
+declare type ForeignKey<A> = A extends AttributeDefinition<Natural, infer E> ? () => Promise<E> : never;
+declare type ModelFKAttributes<A extends AttributesDefinition> = {
+    [a in ForeignKeys<A> & string as `${a}Load`]?: ForeignKey<A[a]>;
+};
+declare type ModelBaseAttributes<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) & {
+declare type ModelAttributes<A extends AttributesDefinition> = keyof ModelFKAttributes<A> extends never ? ModelBaseAttributes<A> : ModelBaseAttributes<A> & ModelFKAttributes<A>;
+declare type Ancestor<A, N extends Natural, T extends EntryBase> = (new () => T) & {
     [a in keyof A]?: Meta<Native<A[a]>, T>;
 } & {
     load: (boh: boolean) => Promise<T[]>;
-} & Meta<N, T>;
+} & Meta<N, T> & {
+    tmp: number;
+};
+declare type ModelBase<E extends EntryBase> = new () => E;
+export declare type Entry<M> = M extends new () => infer E ? E : never;
 export interface SedentaryOptions {
     log?: ((message: string) => void) | null;
     serverless?: boolean;
@@ -73,45 +90,36 @@ 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>, options?: ForeignKeyOptions): Type<N, E>;
+    FKEY<N extends Natural, E extends EntryBase>(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>;
+    checkSize(size: number, message: string): number;
     connect(): Promise<void>;
     end(): Promise<void>;
-    model<A extends AttributesDefinition, M extends Methods<T>, T extends Entry & {
-        id?: string;
-    } & ModelWithMetods<A, M>>(modelName: 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>>(modelName: 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>>(modelName: 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>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
-        methods: M;
-    }): Ancestor<A, number, T>;
-    model<A extends AttributesDefinition, T extends Entry & {
-        id?: string;
-    } & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
-        int8id: true;
-    }): 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>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
-        primaryKey: K;
-    }): 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>>(modelName: string, attributes: A, options?: BaseModelOptions<T> & {
-        parent: P;
-    }): Ancestor<A, N, T>;
-    model<A extends AttributesDefinition, T extends Entry & {
-        id?: number;
-    } & Model<A>>(modelName: string, attributes: A, options?: BaseModelOptions<T>): Ancestor<A, number, T>;
-    checkSize(size: number, message: string): number;
+    model2<E extends EntryBase>(modelName: string): ModelBase<E>;
+    model2<E extends EntryBase, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, methods: M & Record<string, (this: E & M) => void>): ModelBase<E & M>;
+    model<A extends AttributesDefinition, B extends boolean, E extends EntryBase & EntryId<B> & ModelAttributes<A>>(modelName: string, attributes: A, options?: BaseModelOptions<B, E>): Ancestor<A, string, E>;
+    model<A extends AttributesDefinition, B extends boolean, K extends keyof A, P extends Meta<Natural, EntryBase>, N extends P extends {
+        tmp: number;
+    } ? (P extends Meta<infer N, EntryBase> ? N : never) : Native<A[K]>, E extends (P extends {
+        tmp: number;
+    } ? Parent<P> : EntryBase) & ModelAttributes<A>>(modelName: string, attributes: A, options?: BaseModelOptions<B, E> & {
+        parent?: P;
+        primaryKey?: K;
+    }): Ancestor<A, N, E>;
+    model<A extends AttributesDefinition, B extends boolean, E extends EntryBase & EntryId<B> & ModelAttributes<A>, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, attributes: A, options: BaseModelOptions<B, E>, methods: M & Record<string, (this: E & M) => unknown>): Ancestor<A, string, E & M>;
+    model<A extends AttributesDefinition, B extends boolean, K extends keyof A, P extends Meta<Natural, EntryBase>, N extends P extends {
+        tmp: number;
+    } ? (P extends Meta<infer N, EntryBase> ? N : never) : Native<A[K]>, E extends (P extends {
+        tmp: number;
+    } ? Parent<P> : EntryBase) & ModelAttributes<A>, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, attributes: A, options: BaseModelOptions<B, E> & {
+        parent?: P;
+        primaryKey?: K;
+    }, methods: M & Record<string, (this: E & M) => unknown>): Ancestor<A, N, E & M>;
 }
 export declare const Package: typeof Sedentary;
+export declare class Sedentary2 {
+    model<E extends EntryBase>(modelName: string): ModelBase<E>;
+    model<E extends EntryBase, M extends Record<string, <S extends M>(this: E & S) => unknown>>(modelName: string, methods: M & Record<string, (this: E & M) => void>): ModelBase<E & M>;
+}

package/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.Sedentary = exports.Type = exports.Entry = void 0;
+exports.Sedentary2 = exports.Package = exports.Sedentary = exports.Type = exports.EntryBase = 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, "EntryBase", { enumerable: true, get: function () { return db_2.EntryBase; } });
 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 = [
@@ -56,6 +56,13 @@ class Sedentary {
         size = size ? this.checkSize(size, message) : undefined;
         return new db_1.Type({ base: String, size, type: "VARCHAR" });
     }
+    checkSize(size, message) {
+        const str = size.toString();
+        const parsed = parseInt(str, 10);
+        if (str !== parsed.toString())
+            throw new Error(message);
+        return parsed;
+    }
     async connect() {
         try {
             this.log("Connecting...");
@@ -74,7 +81,16 @@ class Sedentary {
         await this.db.end();
         this.log("Connection closed");
     }
-    model(modelName, attributes, options) {
+    model2(modelName, methods) {
+        const ret = function () {
+            this.save();
+        };
+        Object.defineProperty(ret, "name", { value: name });
+        if (methods)
+            Object.assign(ret.prototype, methods);
+        return ret;
+    }
+    model(modelName, attributes, options, methods) {
         if (typeof modelName !== "string")
             throw new Error("Sedentary.model: 'name' argument: Wrong type, expected 'string'");
         if (this.models[modelName])
@@ -98,7 +114,6 @@ class Sedentary {
             throw new Error(`Sedentary.model: '${modelName}' model: 'parent' and 'primaryKey' options conflict each other`);
         let autoIncrement = true;
         const { indexes, int8id, parent, primaryKey, sync, tableName } = Object.assign({ sync: this.sync, tableName: modelName }, options);
-        let { methods } = options;
         let aarray = int8id
             ? [new db_1.Attribute(Object.assign(Object.assign({}, this.INT8()), { attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true }))]
             : [new db_1.Attribute(Object.assign(Object.assign({}, this.INT(4)), { attributeName: "id", fieldName: "id", modelName, notNull: true, tableName, unique: true }))];
@@ -352,13 +367,6 @@ class Sedentary {
             Object.defineProperty(Class, key, { value: pk[key] });
         return Class;
     }
-    checkSize(size, message) {
-        const str = size.toString();
-        const parsed = parseInt(str, 10);
-        if (str !== parsed.toString())
-            throw new Error(message);
-        return parsed;
-    }
 }
 exports.Sedentary = Sedentary;
 exports.Package = Sedentary;
@@ -369,13 +377,15 @@ class Item extends db.model("Item", {
     str: db.VARCHAR()
 }, {
     init: function () {
-        this.num = 0;
+        this.num = "0";
         this.str = "0";
     },
-    int8id: true,
+    int8id: true
+    /*
     methods: {
-        prova: () => "ok"
+      prova: (): string => "ok"
     }
+    */
 }) {
 }
 class Super extends db.model("Super", {
@@ -383,15 +393,17 @@ class Super extends db.model("Super", {
     n: db.FKEY(Item),
     s: db.FKEY(Users.bar)
 }, {
-    parent: Item,
-    init: async function () {
-        this.n = "23";
-        this.id = "0";
-        this.num = 0;
-        const a = this.nLoad ? await this.nLoad() : { prova: () => null };
-        a.prova();
-        this.prova();
+    parent: Item
+    /*
+    init:   async function() {
+      this.n = "23";
+      this.id = 0;
+      this.num = 0;
+      const a = this.nLoad ? await this.nLoad() : { prova: (): null => null };
+      a.prova();
+      this.prova();
     }
+    */
 }) {
 }
 class Next extends db.model("Next", { a: db.INT, b: db.INT }, {
@@ -421,33 +433,49 @@ class Last extends db.model("Last", { c: db.FKEY(Current.b) }, {
     }
     catch (e) {
         console.log(Item.load, item.save, await Item.load(true), item, e.message);
-        console.log(new Next(), Next.load, await Next.load(true), new Last(), item.prova());
+        //console.log(new Next(), Next.load, await Next.load(true), new Last(), item.prova());
     }
     return true;
 })();
-/*
-export let factory = () => {
-    class Foo {
-        a = 3;
-        b = 'bar'
-        c?: boolean
+function model(modelName, attributes, options, methods) {
+    const model = function () { };
+    Object.defineProperty(model, "name", { value: modelName });
+    if (methods)
+        Object.assign(model.prototype, methods);
+    return model;
+}
+const T1 = model("T1", {});
+const t1 = new T1();
+t1.id = 0;
+console.log(t1);
+const T2 = model("T2", { a: db.INT, b: db.VARCHAR }, { int8id: true }, {
+    test: function (repeat = true) {
+        if (repeat)
+            this.b = this.test(false);
+        this.c = this.a = 0;
+        return "test";
+    }
+});
+const t2 = new T2();
+//t2.id = "0";
+const tt2 = (t) => console.log(t, t.test(), t.a, t.b);
+tt2(t2);
+class Sedentary2 {
+    model(modelName, methods) {
+        const ret = function () { };
+        Object.defineProperty(ret, "name", { value: modelName });
+        if (methods)
+            Object.assign(ret.prototype, methods);
+        ret.prototype.save = () => new Promise(resolve => resolve(false));
+        return ret;
     }
-    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
-*/
+exports.Sedentary2 = Sedentary2;
+const db2 = new Sedentary2();
+const T22 = db2.model("T2", {
+    c: function () {
+        this.id = "0";
+        this.c();
+        return 0;
+    }
+});

package/lib/db.d.ts

@@ -1,6 +1,5 @@
 export declare type Natural = Date | Record<string, unknown> | boolean | number | string;
-export declare class Entry {
-    init(): void;
+export declare class EntryBase {
     save(): Promise<boolean>;
 }
 export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";

package/lib/db.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB = exports.Table = exports.Attribute = exports.Meta = exports.Type = exports.Entry = void 0;
-class Entry {
-    init() { }
+exports.DB = exports.Table = exports.Attribute = exports.Meta = exports.Type = exports.EntryBase = void 0;
+/**/
+class EntryBase {
     async save() {
         return false;
     }
 }
-exports.Entry = Entry;
+exports.EntryBase = EntryBase;
 class Type {
     constructor(from) {
         Object.assign(this, from);

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.0",
     "@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.7.0",
+    "@typescript-eslint/parser": "5.7.0",
+    "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,11 @@
     "tsc": "tsc --declaration",
     "version": "node -r ts-node/register utils.ts version"
   },
+  "tsd": {
+    "compilerOptions": {
+      "strict": false
+    }
+  },
   "types": "index.d.ts",
-  "version": "0.0.18"
+  "version": "0.0.19"
 }