sedentary 0.1.0 → 0.1.1

package/dist/types/db.d.ts

@@ -0,0 +1,130 @@
+export declare const actions: unique symbol;
+export declare const base: unique symbol;
+export declare const loaded: unique symbol;
+export declare const size: unique symbol;
+export declare const transaction: unique symbol;
+export type TxAction = {
+    action: "remove";
+    records: number;
+} | {
+    action: "save";
+    records: number | false;
+};
+export declare class EntryBase {
+    constructor(from?: Partial<EntryBase>);
+    construct(): void;
+    postCommit(actions: TxAction[]): void;
+    postLoad(): void;
+    postRemove(deletedRecords: number): void;
+    postSave(savedRecords: number | false): void;
+    preCommit(actions: TxAction[]): void;
+    preLoad(): void;
+    preRemove(): void;
+    preSave(): void;
+    remove(): Promise<boolean>;
+    save(): Promise<number | false>;
+}
+export type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
+export interface ForeignKeyOptions {
+    onDelete?: ForeignKeyActions;
+    onUpdate?: ForeignKeyActions;
+}
+export interface Type<T, N extends boolean, E> {
+    [base]: unknown;
+    entry?: E;
+    native?: T;
+    notNull?: N;
+    [size]?: number;
+    type: string;
+    foreignKey?: {
+        attributeName: string;
+        fieldName: string;
+        options?: ForeignKeyOptions;
+        tableName: string;
+    };
+}
+export declare class Type<T, N extends boolean, E> {
+    constructor(from: Type<T, N, E>);
+}
+export interface Attribute<T, N extends boolean, E> extends Type<T, N, E> {
+    attributeName: string;
+    defaultValue?: unknown;
+    fieldName: string;
+    modelName: string;
+    notNull: N;
+    tableName: string;
+    unique?: boolean;
+}
+export declare class Attribute<T, N extends boolean, E> extends Type<T, N, E> {
+    constructor(from: Attribute<T, N, E>);
+}
+export interface Constraint {
+    attribute: Attribute<unknown, boolean, unknown>;
+    constraintName: string;
+    type: "f" | "u";
+}
+export interface Index {
+    fields: string[];
+    indexName: string;
+    type: "btree" | "hash";
+    unique: boolean;
+}
+interface ITable {
+    attributes: Attribute<unknown, boolean, unknown>[];
+    autoIncrement: boolean;
+    constraints: Constraint[];
+    indexes: Index[];
+    model: {
+        load: (where: any, order?: any, tx?: Transaction) => Promise<EntryBase[]>;
+    };
+    parent?: Attribute<unknown, boolean, unknown>;
+    pk: Attribute<unknown, boolean, unknown>;
+    sync: boolean;
+    tableName: string;
+}
+declare const Table_base: new (defaults?: ITable | undefined) => ITable;
+export declare class Table extends Table_base {
+    autoIncrementOwn?: boolean;
+    oid?: number;
+    findAttribute(name: string): Attribute<unknown, boolean, unknown>;
+    findField(name: string): Attribute<unknown, boolean, unknown>;
+}
+export declare abstract class DB<T extends Transaction> {
+    tables: Table[];
+    protected log: (message: string) => void;
+    protected sync: boolean;
+    abstract connect(): Promise<void>;
+    abstract end(): Promise<void>;
+    constructor(log: (message: string) => void);
+    findTable(name: string): Table;
+    protected indexesEq(a: Index, b: Index): boolean;
+    syncDataBase(): Promise<void>;
+    protected syncLog(message: string): void;
+    abstract begin(): Promise<T>;
+    abstract cancel(tableName: string): (where: string, tx?: Transaction) => Promise<number>;
+    abstract escape(value: unknown): string;
+    abstract load(tableName: string, attributes: Record<string, string>, pk: Attribute<unknown, boolean, unknown>, model: new () => EntryBase, table: Table): (where: string, order?: string | string[], limit?: number, tx?: Transaction, lock?: boolean) => Promise<EntryBase[]>;
+    abstract remove(tableName: string, pk: Attribute<unknown, boolean, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number>;
+    abstract save(tableName: string, attr2field: Record<string, string>, pk: Attribute<unknown, boolean, unknown>): (this: EntryBase & Record<string, unknown>) => Promise<number | false>;
+    abstract dropConstraints(table: Table): Promise<number[]>;
+    abstract dropFields(table: Table): Promise<void>;
+    abstract dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
+    abstract syncConstraints(table: Table): Promise<void>;
+    abstract syncFields(table: Table): Promise<void>;
+    abstract syncIndexes(table: Table): Promise<void>;
+    abstract syncSequence(table: Table): Promise<void>;
+    abstract syncTable(table: Table): Promise<void>;
+}
+export declare class Transaction {
+    private entries;
+    protected log: (message: string) => void;
+    constructor(log: (message: string) => void);
+    addEntry(entry: EntryBase): void;
+    clean(): void;
+    commit(): Promise<void>;
+    protected preCommit(): void;
+    rollback(): Promise<void>;
+}
+export declare function deepCopy(o: unknown): any;
+export declare function deepDiff(a: unknown, b: unknown): boolean;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,165 @@
+import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
+export { Attribute, base, DB, deepCopy, deepDiff, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, loaded, size, Table, Transaction, transaction, TxAction, Type } from "./db";
+export interface AttributeOptions<T, N extends boolean> {
+    defaultValue?: T;
+    fieldName?: string;
+    notNull?: N;
+    unique?: boolean;
+}
+export interface AttributeOptionsSize<T, N extends boolean> extends AttributeOptions<T, N> {
+    size?: number;
+}
+type NotNull<O> = O extends {
+    notNull: true;
+} ? true : false;
+type AttributesDefinitionBase = {
+    [key: string]: [unknown, boolean, unknown];
+};
+export type AttributesDefinition<N extends AttributesDefinitionBase = AttributesDefinitionBase> = keyof N extends never ? {
+    [s: string]: Type<unknown, boolean, unknown>;
+} : {
+    [key in keyof N]: Type<N[key][0], N[key][1], N[key][2]>;
+};
+declare const attributes: unique symbol;
+declare const methods: unique symbol;
+type ForeignKeysAttributes<T, k> = T extends Type<unknown, boolean, infer E> ? (E extends EntryBase ? k : never) : never;
+type ForeignKeys<A extends AttributesDefinition> = Exclude<{
+    [a in keyof A]?: ForeignKeysAttributes<A[a], a>;
+}[keyof A], undefined>;
+type Native<T> = T extends Type<infer N, infer NN, unknown> ? (NN extends true ? N : N | null) : never;
+export type IndexAttributes = string[] | string;
+export interface IndexOptions {
+    attributes: IndexAttributes;
+    type?: "btree" | "hash";
+    unique?: boolean;
+}
+export type IndexDefinition = IndexAttributes | IndexOptions;
+export type IndexesDefinition = {
+    [key: string]: IndexDefinition;
+};
+interface BaseModelOptions {
+    indexes?: IndexesDefinition;
+    sync?: boolean;
+    tableName?: string;
+}
+export interface ModelOptions extends BaseModelOptions {
+    int8id?: boolean;
+    parent?: Attribute<unknown, boolean, EntryBase>;
+    primaryKey?: string;
+}
+type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
+type ConditionBase<A extends AttributesDefinition> = string | {
+    [a in keyof A]?: ConditionAttribute<Native<A[a]>>;
+};
+type Condition<A extends AttributesDefinition> = ConditionBase<A> | ["NOT", Condition<A>] | ["AND", ...Condition<A>[]] | ["OR", ...Condition<A>[]];
+type Order_<A extends AttributesDefinition> = keyof A | `-${string & keyof A}`;
+type Order<A extends AttributesDefinition> = Order_<A> | Order_<A>[];
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+type BaseKeyType<B extends boolean> = IsUnion<B> extends true ? number : B extends true ? string : number;
+type KeyType<B extends boolean, P extends ModelStd> = P extends new () => EntryBase ? (P extends Attribute<infer T, boolean, EntryBase> ? T : never) : BaseKeyType<B>;
+type ForeignKey<A> = A extends Type<unknown, boolean, infer E> ? () => Promise<E> : never;
+type EntryBaseAttributes<A extends AttributesDefinition> = {
+    [a in keyof A]: Native<A[a]>;
+};
+type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P[typeof methods] : EntryBase;
+type EntryMethodsFK<A extends AttributesDefinition> = {
+    [a in ForeignKeys<A> & string as `${a}Load`]: ForeignKey<A[a]>;
+};
+type EntryMethods<A extends AttributesDefinition, P extends ModelStd> = keyof EntryMethodsFK<A> extends never ? EntryMethodsBase<P> : EntryMethodsBase<P> & EntryMethodsFK<A>;
+type ModelAttributesIf<A extends AttributesDefinition, T> = keyof A extends never ? T : T & A;
+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[typeof attributes] : {
+    id: Type<BaseKeyType<B>, true, 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[]>;
+    cancel(where: Condition<A>, tx?: Transaction): Promise<number>;
+}
+type ModelBase<T, A extends AttributesDefinition, EA extends Record<string, unknown>, EM extends EntryBase, E extends EntryBase> = (new (from?: Partial<EA>, tx?: Transaction) => E) & Attribute<T, true, E> & {
+    [attributes]: A;
+    foreignKeys: Record<string, boolean>;
+    [methods]: EM;
+    parent?: ModelStd;
+    tableName: string;
+} & {
+    [a in keyof A]: Attribute<Native<A[a]>, boolean, E>;
+} & ModelLoad<A, E>;
+type Model<T, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<T, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
+type ModelStd = Attribute<unknown, true, EntryBase> & {
+    [attributes]: AttributesDefinition;
+    foreignKeys: Record<string, boolean>;
+    [methods]: EntryBase;
+    parent?: ModelStd;
+};
+export type Entry<M> = M extends new () => infer E ? E : never;
+export 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 type Where<M> = M extends {
+    load(where: infer T): void;
+} ? T : never;
+export interface SedentaryOptions {
+    autoSync?: boolean;
+    log?: ((message: string) => void) | null;
+    sync?: boolean;
+}
+/**
+ * Converts a JavaScript name to the default SQL name (snake_case).
+ * Uppercase letters become lowercase preceded by underscore, except the first character
+ * which is only lowercased without underscore.
+ */
+export declare function toSqlName(name: string): string;
+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<O extends AttributeOptions<boolean, boolean> | undefined = undefined>(options?: O): Type<boolean, NotNull<O>, unknown>;
+    DateTime<O extends AttributeOptions<Date, boolean> | undefined = undefined>(options?: O): Type<Date, NotNull<O>, unknown>;
+    FKey<T, E extends EntryBase>(attribute: Attribute<T, boolean, E>, options?: ForeignKeyOptions): Type<T, boolean, E>;
+    Float<O extends AttributeOptionsSize<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
+    Int<O extends AttributeOptionsSize<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
+    Int8<O extends AttributeOptions<bigint, boolean> | undefined = undefined>(options?: O): Type<bigint, NotNull<O>, unknown>;
+    JSON<T = unknown>(): Type<T, false, unknown>;
+    JSON<T = unknown>(options: {
+        notNull: true;
+    } & AttributeOptions<T, boolean>): Type<T, true, unknown>;
+    JSON<T = unknown>(options: AttributeOptions<T, boolean>): Type<T, boolean, unknown>;
+    Number<O extends AttributeOptions<number, boolean> | undefined = undefined>(options?: O): Type<number, NotNull<O>, unknown>;
+    None<T = unknown>(): Type<T, false, unknown>;
+    None<T = unknown>(options: {
+        notNull: true;
+    } & AttributeOptions<unknown, boolean>): Type<T, true, unknown>;
+    None<T = unknown>(options: AttributeOptions<unknown, boolean>): Type<T, boolean, unknown>;
+    VarChar<S extends string = string>(): Type<S, false, unknown>;
+    VarChar<S extends string = string>(options: {
+        notNull: true;
+    } & AttributeOptionsSize<S, boolean>): Type<S, true, unknown>;
+    VarChar<S extends string = string>(options: AttributeOptionsSize<S, boolean>): Type<S, boolean, 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: unknown): 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/package.json

@@ -9,6 +9,9 @@
   "engines": {
     "node": ">=20.19"
   },
+  "files": [
+    "dist"
+  ],
   "funding": {
     "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
   },
@@ -34,23 +37,6 @@
     "deploy": "make deploy",
     "preinstall": "if [ -f Makefile ] ; then make ; fi"
   },
-  "tsd": {
-    "compilerOptions": {
-      "alwaysStrict": true,
-      "composite": false,
-      "esModuleInterop": true,
-      "moduleResolution": "Node",
-      "noImplicitAny": true,
-      "noImplicitReturns": true,
-      "noImplicitThis": true,
-      "strict": true,
-      "strictBindCallApply": true,
-      "strictFunctionTypes": true,
-      "strictNullChecks": true,
-      "strictPropertyInitialization": true,
-      "target": "ESNext"
-    }
-  },
   "types": "./dist/types/index.d.ts",
-  "version": "0.1.0"
+  "version": "0.1.1"
 }