sedentary 0.0.15 → 0.0.19

package/README.md

@@ -118,10 +118,6 @@ To work with the package under Windows, be sure to configure `bash.exe` as your
 
 Do not hesitate to report any bug or inconsistency [@github](https://github.com/iccicci/sedentary/issues).
 
-# ChangeLog
-
-[ChangeLog](https://github.com/iccicci/sedentary/blob/master/CHANGELOG.md)
-
 # Donating
 
 If you find useful this package, please consider the opportunity to donate some satoshis to this bitcoin address:

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, 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>): 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>>(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<A>>(name: 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>>(name: 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>>(name: string, attributes: A, options?: BaseModelOptions<T> & {
-        parent: P;
-    }): Ancestor<A, N, T>;
-    model<A extends AttributesDefinition, T extends Entry & {
-        id?: number;
-    } & Model<A>>(name: 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>;
+}