sedentary 0.0.40 → 0.0.43

package/dist/types/index.d.ts

@@ -1,141 +0,0 @@
-import { Attribute, DB, EntryBase, ForeignKeyOptions, Natural, Transaction, Type } from "./db";
-export { Attribute, DB, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, Natural, Table, Transaction, Type } from "./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, E>;
-    unique?: boolean;
-}
-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 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, N extends Natural, E> = T extends {
-    notNull: true;
-} ? Native___<Type<N, E>> : Native___<Type<N, E>> | null;
-declare type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native_<T, N, E> : Native__<T> | null;
-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;
-};
-interface BaseModelOptions {
-    indexes?: IndexesDefinition;
-    sync?: boolean;
-    tableName?: string;
-}
-export interface ModelOptions extends BaseModelOptions {
-    int8id?: boolean;
-    parent?: Attribute<Natural, EntryBase>;
-    primaryKey?: string;
-}
-declare type ConditionAttribute<N extends Natural> = N | ["=" | ">" | "<" | ">=" | "<=" | "<>", N] | ["IN", N[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
-declare type ConditionBase<A extends AttributesDefinition> = string | {
-    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
-};
-declare type Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
-declare type Order_<A extends AttributesDefinition> = keyof A | `-${string & keyof A}`;
-declare type Order<A extends AttributesDefinition> = Order_<A> | Order_<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]>;
-};
-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: {
-        notNull: true;
-        type: Type<BaseKeyType<B>, unknown>;
-    };
-}>;
-export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase> {
-    load(where: Condition<A>, order?: Order<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
-    load(where: Condition<A>, order?: Order<A>, tx?: Transaction, lock?: boolean): Promise<E[]>;
-    load(where: Condition<A>, limit?: number, tx?: Transaction, lock?: boolean): Promise<E[]>;
-    load(where: Condition<A>, tx: Transaction, lock?: boolean): Promise<E[]>;
-}
-declare type ModelBase<N extends Natural, A extends AttributesDefinition, EA extends Record<string, Natural>, EM extends EntryBase, E extends EntryBase> = (new (from?: Partial<EA>, tx?: Transaction) => E) & Attribute<N, E> & {
-    attributes: A;
-    foreignKeys: Record<string, boolean>;
-    methods: EM;
-    parent?: ModelStd;
-    tableName: string;
-} & {
-    [a in keyof A]: Attribute<Native<A[a]>, E>;
-} & ModelLoad<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 OrderBy<M> = M extends {
-    load(where: unknown, order?: infer T): void;
-    load(where: unknown, limit?: number): void;
-    load(where: unknown, tx?: Transaction): void;
-} ? Exclude<T, undefined> : never;
-export declare type Where<M> = M extends {
-    load(where: infer T): void;
-} ? T : never;
-export interface SedentaryOptions {
-    autoSync?: boolean;
-    log?: ((message: string) => void) | null;
-    sync?: boolean;
-}
-export declare class Sedentary<D extends DB<T>, T extends Transaction> {
-    protected autoSync: boolean;
-    protected db: D;
-    protected doSync: boolean;
-    protected log: (message: string) => void;
-    private models;
-    constructor(options?: SedentaryOptions);
-    BOOLEAN(): Type<boolean, unknown>;
-    DATETIME(): Type<Date, unknown>;
-    FKEY<N extends Natural, E extends EntryBase>(attribute: Attribute<N, E>, options?: ForeignKeyOptions): Type<N, E>;
-    INT(size?: number): Type<number, unknown>;
-    INT8(): Type<BigInt, unknown>;
-    NUMBER(): Type<number, unknown>;
-    VARCHAR(size?: number): Type<string, unknown>;
-    private checkDB;
-    private checkOrderBy;
-    private checkSize;
-    private createWhere;
-    connect(sync?: boolean): Promise<void>;
-    sync(): Promise<void>;
-    end(): Promise<void>;
-    begin(): Promise<T>;
-    escape(value: Natural): string;
-    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>;
-}

package/jest.config.js

@@ -1,8 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-module.exports = {
-  collectCoverageFrom:    ["db.ts", "index.ts"],
-  preset:                 "ts-jest",
-  testEnvironment:        "jest-environment-node-single-context",
-  testPathIgnorePatterns: ["/node_modules/", "/sedentary-pg/"],
-  testSequencer:          "./testSequencer.js"
-};

package/testSequencer.js

@@ -1,20 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const Sequencer = require("@jest/test-sequencer").default;
-
-class CustomSequencer extends Sequencer {
-  shard(tests, { shardIndex, shardCount }) {
-    const shardSize = Math.ceil(tests.length / shardCount);
-    const shardStart = shardSize * (shardIndex - 1);
-    const shardEnd = shardSize * shardIndex;
-
-    return [...tests].sort((a, b) => (a.path > b.path ? 1 : -1)).slice(shardStart, shardEnd);
-  }
-
-  sort(tests) {
-    const copyTests = Array.from(tests);
-
-    return copyTests.sort((testA, testB) => (testA.path > testB.path ? 1 : -1));
-  }
-}
-
-module.exports = CustomSequencer;