sedentary 0.0.16 → 0.0.20

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 { Attribute, DB, EntryBase, ForeignKeyOptions, 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,17 +12,13 @@ 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 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>;
 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;
@@ -33,34 +29,59 @@ export declare type IndexDefinition = IndexAttributes | IndexOptions;
 export declare type IndexesDefinition = {
     [key: string]: IndexDefinition;
 };
-declare type BaseModelOptions<T> = {
+interface BaseModelOptions {
     indexes?: IndexesDefinition;
-    init?: (this: T) => void;
     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> & {
+}
+export interface ModelOptions extends BaseModelOptions {
     int8id?: boolean;
-    methods?: M;
-    parent?: P;
-    primaryKey?: K;
+    parent?: Type<Natural, EntryBase>;
+    primaryKey?: string;
+}
+declare type ConditionAttribute<N extends Natural> = N | [">" | "<" | ">=" | "<=" | "<>", N] | ["LIKE", string] | ["IN", ...N[]];
+declare type ConditionBase<A extends AttributesDefinition> = string | {
+    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
 };
-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 Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
+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 BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
+declare type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, EntryBase> ? T : never) : BaseKeyType<B>;
+declare type ForeignKey<A> = A extends AttributeDefinition<Natural, infer E> ? () => Promise<E> : never;
+declare type EntryBaseAttributes<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>;
+declare type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P["methods"] : EntryBase;
+declare type EntryMethodsFK<A extends AttributesDefinition> = {
+    [a in ForeignKeys<A> & string as `${a}Load`]: ForeignKey<A[a]>;
+};
+declare type EntryMethods<A extends AttributesDefinition, P extends ModelStd> = keyof EntryMethodsFK<A> extends never ? EntryMethodsBase<P> : EntryMethodsBase<P> & EntryMethodsFK<A>;
+declare type ModelAttributesIf<A extends AttributesDefinition, T> = keyof A extends never ? T : T & A;
+declare type ModelAttributes<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd> = K extends keyof A ? A : ModelAttributesIf<A, P extends new () => EntryBase ? P["attributes"] : {
+    id: Type<BaseKeyType<B>, unknown>;
+}>;
+declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA extends Record<string, Natural | undefined>, EM extends EntryBase, E extends EntryBase> = (new (from?: EA) => E) & Attribute<N, E> & {
+    attributes: A;
+    foreignKeys: Record<string, boolean>;
+    methods: EM;
+    parent?: ModelStd;
+    tableName: string;
+    load: (where?: Condition<A>) => Promise<E[]>;
 } & {
-    load: (boh: boolean) => Promise<T[]>;
-} & Meta<N, T>;
+    [a in keyof A]: Attribute<Native<A[a]>, E>;
+};
+declare type Model<N extends Natural, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<N, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
+declare type ModelStd = Attribute<Natural, EntryBase> & {
+    attributes: AttributesDefinition;
+    foreignKeys: Record<string, boolean>;
+    methods: EntryBase;
+    parent?: ModelStd;
+};
+export declare type Entry<M> = M extends new () => infer E ? E : never;
+export declare type Where<M> = M extends {
+    load: (where: infer T) => void;
+} ? Exclude<T, undefined> : never;
 export interface SedentaryOptions {
     log?: ((message: string) => void) | null;
     serverless?: boolean;
@@ -73,45 +94,22 @@ 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: Attribute<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;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EM extends EntryMethods<A, P>>(modelName: string, attributes: A, options?: BaseModelOptions & {
+        int8id?: B;
+        parent?: P;
+        primaryKey?: K | keyof A;
+    }): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM>;
+    model<A extends AttributesDefinition, B extends boolean, K extends string, P extends ModelStd, EA extends EntryBaseAttributes<ModelAttributes<A, B, K, P>>, EM extends EntryMethods<A, P>, M extends Record<string, <S extends M>(this: EA & EM & S, ...args: any[]) => void>>(modelName: string, attributes: A, options: BaseModelOptions & {
+        int8id?: B;
+        parent?: P;
+        primaryKey?: K | keyof A;
+    }, methods: M & Record<keyof M, (this: EA & EM & M, ...args: any[]) => void>): Model<K extends keyof A ? Native<A[K]> : KeyType<B, P>, ModelAttributes<A, B, K, P>, EM & M>;
 }
 export declare const Package: typeof Sedentary;