sedentary 0.0.54 → 0.1.1

package/dist/types/index.d.ts

@@ -1,29 +1,32 @@
 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 type TypeDefinition<T, E> = (() => Type<T, E>) | Type<T, E>;
-export interface AttributeOptions<T, E> {
+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?: boolean;
-    type: TypeDefinition<T, E>;
+    notNull?: N;
     unique?: boolean;
 }
-export type AttributeDefinition<T, E> = TypeDefinition<T, E> | AttributeOptions<T, E>;
-export type AttributesDefinition = {
-    [key: string]: AttributeDefinition<unknown, unknown>;
+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 AttributeDefinition<unknown, infer E> ? (E extends EntryBase ? k : never) : never;
-type ForeignKeys<A extends AttributesDefinition> = {
+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];
-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;
-type Native<T> = T extends AttributeOptions<infer N, infer E> ? Native_<T, N, E> : Native__<T> | null;
+}[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;
@@ -41,7 +44,7 @@ interface BaseModelOptions {
 }
 export interface ModelOptions extends BaseModelOptions {
     int8id?: boolean;
-    parent?: Attribute<unknown, EntryBase>;
+    parent?: Attribute<unknown, boolean, EntryBase>;
     primaryKey?: string;
 }
 type ConditionAttribute<T> = T | ["=" | ">" | "<" | ">=" | "<=" | "<>", T] | ["IN", T[]] | ["IS NULL"] | ["LIKE", string] | ["NOT"];
@@ -54,8 +57,8 @@ 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 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]>;
 };
@@ -66,10 +69,7 @@ type EntryMethodsFK<A extends AttributesDefinition> = {
 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>;
-    };
+    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[]>;
@@ -78,17 +78,17 @@ 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>;
 }
-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, true, E> & {
     [attributes]: A;
     foreignKeys: Record<string, boolean>;
     [methods]: EM;
     parent?: ModelStd;
     tableName: string;
 } & {
-    [a in keyof A]: Attribute<Native<A[a]>, E>;
+    [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, EntryBase> & {
+type ModelStd = Attribute<unknown, true, EntryBase> & {
     [attributes]: AttributesDefinition;
     foreignKeys: Record<string, boolean>;
     [methods]: EntryBase;
@@ -108,6 +108,12 @@ export interface SedentaryOptions {
     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;
@@ -115,16 +121,28 @@ export declare class Sedentary<D extends DB<T>, T extends Transaction> {
     protected log: (message: string) => void;
     private models;
     constructor(options?: SedentaryOptions);
-    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>;
-    Number(): Type<number, unknown>;
-    None<T>(): Type<T, unknown>;
-    VarChar<S extends string>(_size?: number): Type<S, unknown>;
+    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;

package/package.json

@@ -7,28 +7,26 @@
   ],
   "description": "The ORM which never needs to migrate",
   "engines": {
-    "node": ">=18.0"
+    "node": ">=20.19"
   },
+  "files": [
+    "dist"
+  ],
   "funding": {
     "url": "https://blockchain.info/address/1Md9WFAHrXTb3yPBwQWmUfv2RmzrtbHioB"
   },
-  "homepage": "https://github.com/iccicci/sedentary/packages/sedentary#readme",
+  "homepage": "https://github.com/iccicci/sedentary/tree/master/packages/sedentary#readme",
   "keywords": [
     "DB",
     "ORM",
     "database",
     "migration",
-    "mysql",
-    "postgresql",
-    "sqlite"
+    "postgresql"
   ],
   "license": "MIT",
   "main": "./dist/cjs/index.js",
   "module": "./dist/es/index.js",
   "name": "sedentary",
-  "optionalDependencies": {
-    "fsevents": "^2.3.3"
-  },
   "readmeFilename": "README.md",
   "repository": {
     "type": "git",
@@ -36,30 +34,9 @@
   },
   "scripts": {
     "build": "make build",
-    "coverage": "jest --coverage --no-cache --runInBand",
     "deploy": "make deploy",
-    "precoverage": "make pretest",
-    "preinstall": "if [ -f Makefile ] ; then make ; fi",
-    "pretest": "make pretest",
-    "test": "jest --no-cache --runInBand"
-  },
-  "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"
-    }
+    "preinstall": "if [ -f Makefile ] ; then make ; fi"
   },
   "types": "./dist/types/index.d.ts",
-  "version": "0.0.54"
+  "version": "0.1.1"
 }