sedentary 0.0.52 → 0.0.54

package/dist/cjs/index.js

@@ -57,8 +57,15 @@ class Sedentary {
         const { attributeName, fieldName, tableName, type, [db_1.base]: _base, [db_1.size]: _size } = attribute;
         return new db_1.Type({ [db_1.base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [db_1.size]: _size, type });
     }
+    Float(_size) {
+        const message = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
+        _size = _size ? this.checkSize(_size, message) : 8;
+        if (_size !== 4 && _size !== 8)
+            throw new Error(message);
+        return new db_1.Type({ [db_1.base]: Number, [db_1.size]: _size, type: "FLOAT" });
+    }
     Int(_size) {
-        const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
+        const message = "Sedentary.Int: 'size' argument: Wrong value, expected 2 or 4";
         _size = _size ? this.checkSize(_size, message) : 4;
         if (_size !== 2 && _size !== 4)
             throw new Error(message);
@@ -77,7 +84,7 @@ class Sedentary {
         return new db_1.Type({ [db_1.base]: undefined, type: "NONE" });
     }
     VarChar(_size) {
-        const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
+        const message = "Sedentary.VarChar: 'size' argument: Wrong value, expected positive integer";
         _size = _size ? this.checkSize(_size, message) : undefined;
         return new db_1.Type({ [db_1.base]: String, [db_1.size]: _size, type: "VARCHAR" });
     }
@@ -272,7 +279,7 @@ class Sedentary {
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
                 if (func === this.FKey)
                     throw new Error(`${message1} 'this.FKey' can't be used directly`);
-                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
+                if (![this.Boolean, this.DateTime, this.Float, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new db_1.Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };

package/dist/es/index.js

@@ -45,8 +45,15 @@ export class Sedentary {
         const { attributeName, fieldName, tableName, type, [base]: _base, [size]: _size } = attribute;
         return new Type({ [base]: _base, foreignKey: { attributeName, fieldName, options, tableName }, [size]: _size, type });
     }
+    Float(_size) {
+        const message = "Sedentary.Float: 'size' argument: Wrong value, expected 4 or 8";
+        _size = _size ? this.checkSize(_size, message) : 8;
+        if (_size !== 4 && _size !== 8)
+            throw new Error(message);
+        return new Type({ [base]: Number, [size]: _size, type: "FLOAT" });
+    }
     Int(_size) {
-        const message = "Sedentary.INT: 'size' argument: Wrong value, expected 2 or 4";
+        const message = "Sedentary.Int: 'size' argument: Wrong value, expected 2 or 4";
         _size = _size ? this.checkSize(_size, message) : 4;
         if (_size !== 2 && _size !== 4)
             throw new Error(message);
@@ -65,7 +72,7 @@ export class Sedentary {
         return new Type({ [base]: undefined, type: "NONE" });
     }
     VarChar(_size) {
-        const message = "Sedentary.VARCHAR: 'size' argument: Wrong value, expected positive integer";
+        const message = "Sedentary.VarChar: 'size' argument: Wrong value, expected positive integer";
         _size = _size ? this.checkSize(_size, message) : undefined;
         return new Type({ [base]: String, [size]: _size, type: "VARCHAR" });
     }
@@ -260,7 +267,7 @@ export class Sedentary {
             const call = (defaultValue, fieldName, notNull, unique, func, message1, message2) => {
                 if (func === this.FKey)
                     throw new Error(`${message1} 'this.FKey' can't be used directly`);
-                if (![this.Boolean, this.DateTime, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
+                if (![this.Boolean, this.DateTime, this.Float, this.Int, this.JSON, this.Int8, this.None, this.Number, this.VarChar].includes(func))
                     throw new Error(`${message1} ${message2}`);
                 return new Attribute({ attributeName, defaultValue, fieldName, modelName, notNull, tableName, unique, ...func() });
             };

package/dist/types/db.d.ts

@@ -21,7 +21,7 @@ export declare class EntryBase {
     remove(): Promise<boolean>;
     save(): Promise<boolean>;
 }
-export declare type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
+export type ForeignKeyActions = "cascade" | "no action" | "restrict" | "set default" | "set null";
 export interface ForeignKeyOptions {
     onDelete?: ForeignKeyActions;
     onUpdate?: ForeignKeyActions;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import { Attribute, DB, EntryBase, ForeignKeyOptions, Transaction, Type } from "./db";
 export { Action, Attribute, base, DB, deepCopy, deepDiff, EntryBase, ForeignKeyActions, ForeignKeyOptions, Index, loaded, size, Table, Transaction, transaction, Type } from "./db";
-export declare type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
+export type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
 export interface AttributeOptions<T, E> {
     defaultValue?: T;
     fieldName?: string;
@@ -8,30 +8,30 @@ export interface AttributeOptions<T, E> {
     type: TypeDefinition<T, E>;
     unique?: boolean;
 }
-export declare type AttributeDefinition<T, E> = TypeDefinition<T, E> | AttributeOptions<T, E>;
-export declare type AttributesDefinition = {
+export type AttributeDefinition<T, E> = TypeDefinition<T, E> | AttributeOptions<T, E>;
+export type AttributesDefinition = {
     [key: string]: AttributeDefinition<unknown, unknown>;
 };
 declare const attributes: unique symbol;
 declare const methods: unique symbol;
-declare type ForeignKeysAttributes<T, k> = T extends AttributeDefinition<unknown, infer E> ? (E extends EntryBase ? k : never) : never;
-declare type ForeignKeys<A extends AttributesDefinition> = {
+type ForeignKeysAttributes<T, k> = T extends AttributeDefinition<unknown, infer E> ? (E extends EntryBase ? k : never) : never;
+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, E> = T extends {
+type Native___<T> = T extends Type<infer N, unknown> ? N : never;
+type Native__<T> = T extends () => Type<infer N, infer E> ? Native___<Type<N, E>> : Native___<T>;
+type Native_<T, N, 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;
+type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native_<T, N, E> : Native__<T> | null;
+export type IndexAttributes = string[] | string;
 export interface IndexOptions {
     attributes: IndexAttributes;
     type?: "btree" | "hash";
     unique?: boolean;
 }
-export declare type IndexDefinition = IndexAttributes | IndexOptions;
-export declare type IndexesDefinition = {
+export type IndexDefinition = IndexAttributes | IndexOptions;
+export type IndexesDefinition = {
     [key: string]: IndexDefinition;
 };
 interface BaseModelOptions {
@@ -44,28 +44,28 @@ export interface ModelOptions extends BaseModelOptions {
     parent?: Attribute<unknown, EntryBase>;
     primaryKey?: string;
 }
-declare type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
-declare type ConditionBase<A extends AttributesDefinition> = 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]>>;
 };
-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<unknown, infer E> ? () => Promise<E> : never;
-declare type EntryBaseAttributes<A extends AttributesDefinition> = {
+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, EntryBase> ? T : never) : BaseKeyType<B>;
+type ForeignKey<A> = A extends AttributeDefinition<unknown, infer E> ? () => Promise<E> : never;
+type EntryBaseAttributes<A extends AttributesDefinition> = {
     [a in keyof A]: Native<A[a]>;
 };
-declare type EntryMethodsBase<P extends ModelStd> = P extends new () => EntryBase ? P[typeof methods] : EntryBase;
-declare type EntryMethodsFK<A extends AttributesDefinition> = {
+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]>;
 };
-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[typeof attributes] : {
+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: {
         notNull: true;
         type: Type<BaseKeyType<B>, unknown>;
@@ -78,7 +78,7 @@ export interface ModelLoad<A extends AttributesDefinition, E extends EntryBase>
     load(where: Condition<A>, tx: Transaction, lock?: boolean): Promise<E[]>;
     cancel(where: Condition<A>, tx?: Transaction): Promise<number>;
 }
-declare 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, E> & {
+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, E> & {
     [attributes]: A;
     foreignKeys: Record<string, boolean>;
     [methods]: EM;
@@ -87,20 +87,20 @@ declare type ModelBase<T, A extends AttributesDefinition, EA extends Record<stri
 } & {
     [a in keyof A]: Attribute<Native<A[a]>, E>;
 } & ModelLoad<A, E>;
-declare type Model<T, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<T, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
-declare type ModelStd = Attribute<unknown, EntryBase> & {
+type Model<T, A extends AttributesDefinition, EM extends EntryBase> = ModelBase<T, A, EntryBaseAttributes<A>, EM, EntryBaseAttributes<A> & EM>;
+type ModelStd = Attribute<unknown, 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 {
+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 declare type Where<M> = M extends {
+export type Where<M> = M extends {
     load(where: infer T): void;
 } ? T : never;
 export interface SedentaryOptions {
@@ -118,6 +118,7 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     Boolean(): Type<boolean, unknown>;
     DateTime(): Type<Date, unknown>;
     FKey<T, E extends EntryBase>(attribute: Attribute<T, E>, options?: ForeignKeyOptions): Type<T, E>;
+    Float(_size?: number): Type<number, unknown>;
     Int(_size?: number): Type<number, unknown>;
     Int8(): Type<bigint, unknown>;
     JSON<T>(): Type<T, unknown>;

package/package.json

@@ -7,7 +7,7 @@
   ],
   "description": "The ORM which never needs to migrate",
   "engines": {
-    "node": ">=14.0"
+    "node": ">=18.0"
   },
   "funding": {
     "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
@@ -27,10 +27,13 @@
   "module": "./dist/es/index.js",
   "name": "sedentary",
   "optionalDependencies": {
-    "fsevents": "2.3.2"
+    "fsevents": "^2.3.3"
   },
   "readmeFilename": "README.md",
-  "repository": "https://github.com/iccicci/sedentary",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iccicci/sedentary.git"
+  },
   "scripts": {
     "build": "make build",
     "coverage": "jest --coverage --no-cache --runInBand",
@@ -58,5 +61,5 @@
     }
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.52"
+  "version": "0.0.54"
 }