tspace-mysql 1.5.1 → 1.5.3

package/README.md

@@ -2039,6 +2039,7 @@ import { User } from './User.ts'
 const schemaPhone = {
     id :new Blueprint().int().notNull().primary().autoIncrement(),
     uuid :new Blueprint().varchar(50).null(),
+    userId : new Blueprint().int().notNull(),
     number :new Blueprint().varchar(50).notNull(),
     createdAt :new Blueprint().timestamp().null(),
     updatedAt :new Blueprint().timestamp().null()
@@ -2179,11 +2180,8 @@ const users = await new User().where('idx',1).delete() ❌
 ### Safety Relationships
 
 ```js
-
-import { User , schemaUserType } from './User.ts'
-import { Phone, schemaPhoneType } from './Phone.ts'
-
-+--------------------------------------------------------------------------+
+import { User } from './User.ts'
+import { Phone } from './Phone.ts'
 // Case #1 : Relationship with 2 relations 'phone' and 'phones'
   const users = await new User()
   .relations('phone','phones')
@@ -2225,7 +2223,7 @@ for(const user of users) {
 
 +--------------------------------------------------------------------------+
 
-// Case #2 : Relationship with 2 relations 'phone' and 'phones' and nested relations to 'user'
+// Case #2 : There is a relationship between two entities, 'phone' and 'phones', both of which are related to the 'user' entity through nested relations
   const users = await new User()
   .relations('phone','phones')
   .relationQuery('phone' , (query : Phone) => query.relations('user'))
@@ -2272,6 +2270,110 @@ for(const user of users) {
   }
 
 +--------------------------------------------------------------------------+
+// If you don't want to set types for every returning method such as 'findOne', 'findMany', and so on...
+
+import { Model , Blueprint , SchemaType , RelationType } from 'tspace-mysql'
+import { Phone , SchemaPhoneType }  from '../Phone'
+
+const schemaUser = {
+    id :new Blueprint().int().notNull().primary().autoIncrement(),
+    uuid :new Blueprint().varchar(50).null(),
+    email :new Blueprint().varchar(50).null(),
+    name :new Blueprint().varchar(255).null(),
+    username : new Blueprint().varchar(255).null(),
+    password : new Blueprint().varchar(255).null(),
+    createdAt :new Blueprint().timestamp().null(),
+    updatedAt :new Blueprint().timestamp().null()
+}
+
+type SchemaUserType = SchemaType<typeof schemaUser>
+
+type RelationUserType =  RelationType<{
+    phones : SchemaPhoneType[]
+    phone : SchemaPhoneType
+}>
+
+class User extends Model<SchemaUserType, RelationUserType>  {
+  constructor() {
+    super()
+    this.useSchema(schemaUser)
+    this.hasOne({ model : Phone, name : 'phonex' }) ❌
+    this.hasMany({ model : Phone, name : 'phonesx' }) ❌
+    this.hasOne({ model : Phone, name : 'phone' }) ✅
+    this.hasMany({ model : Phone, name : 'phones' }) ✅
+  }
+}
+
+export { User , SchemaUserType }
+
++--------------------------------------------------------------------------+
+
+// in file Phone.ts
+import { Model , Blueprint , SchemaType , RelationType} from 'tspace-mysql'
+import { User } from './User.ts'
+const schemaPhone = {
+    id :new Blueprint().int().notNull().primary().autoIncrement(),
+    uuid :new Blueprint().varchar(50).null(),
+    userId : new Blueprint().int().notNull(),
+    number :new Blueprint().varchar(50).notNull(),
+    createdAt :new Blueprint().timestamp().null(),
+    updatedAt :new Blueprint().timestamp().null()
+}
+
+type SchemaPhoneType = SchemaType<typeof schemaPhone>
+
+type RelationPhoneType = RelationType<{
+    user : SchemaPhoneType[]
+}>
+
+class Phone extends Model<SchemaPhoneType,RelationPhoneType>  {
+  constructor() {
+    super()
+    this.useSchema(schemaPhone)
+    this.useBelongsTo({ model : User, name : 'userx'}) ❌
+    this.useBelongsTo({ model : User, name : 'user'}) ✅
+  }
+}
+
+export { Phone , SchemaPhoneType }
+
++--------------------------------------------------------------------------+
+
+const users = await new User()
+  .relations('phonex','phonesx') ❌
+  .relationQuery('phonex' ❌ , (query : Phone) => query.relations('user')) ✅
+  .relationQuery('phonesx' ❌ , (query : Phone) => query.relations('user')) ✅
+  .findMany()
+
+const users = await new User()
+  .relations('phone','phones') ✅
+  .relationQuery('phonex' ❌ , (query : Phone) => query.relations('user')) ✅
+  .relationQuery('phonesx' ❌ , (query : Phone) => query.relations('user')) ✅
+  .findMany()
+
+const users = await new User()
+  .relations('phone','phones')
+  .relationQuery('phone' , (query : Phone) => query.relations('userx')) ❌
+  .relationQuery('phones' , (query : Phone) => query.relations('userx')) ❌
+  .findMany()
+
+const users = await new User()
+  .relations('phone','phones') ✅
+  .relationQuery('phone' ✅ , (query : Phone) => query.relations('user')) ✅
+  .relationQuery('phones'✅ , (query : Phone) => query.relations('user')) ✅
+  .findMany()
+
+  for(const user of users) {
+    user.phone.user ❌
+    user.phone?.user ✅
+    user.phone?.user.id ✅
+    user.phone?.userx ❌
+    user.phone?.user.idx ❌
+    user.phones.map(phone =>phone?.user.id) ❌
+    user.phones?.map(phone =>phone?.user.id) ✅
+    user.phones?.map(phone =>phone?.user.idx) ❌
+  }
+
 ```
 
 ## Blueprint

package/build/lib/Interface.d.ts

@@ -1,6 +1,6 @@
 import Model from "./core/Model";
-export interface Relation {
-    name: string;
+export interface Relation<K = any> {
+    name: K extends void ? never : K;
     model: new () => Model;
     as?: string | undefined;
     localKey?: string | undefined;
@@ -16,8 +16,8 @@ export interface Relation {
     oldVersion?: boolean | undefined;
     modelPivot?: new () => Model | undefined;
 }
-export interface RelationQuery {
-    name?: string;
+export interface RelationQuery<K = any> {
+    name?: K extends void ? never : K;
     model: new () => Model;
     as?: string | undefined;
     localKey?: string | undefined;

package/build/lib/connection/options.js

@@ -21,7 +21,7 @@ const environment = () => {
 dotenv_1.default.config({ path: environment() });
 const ENV = process.env;
 const env = {
-    HOST: ENV.DB_HOST || ENV.TSPACE_HOST,
+    HOST: ENV.DB_HOST || ENV.TSPACE_HOST || 'localhost',
     PORT: ENV.DB_PORT || ENV.TSPACE_PORT || 3306,
     USERNAME: ENV.DB_USERNAME || ENV.TSPACE_USERNAME || ENV.DB_USER,
     PASSWORD: ENV.DB_PASSWORD || ENV.TSPACE_PASSWORD || '',

package/build/lib/constants/index.d.ts

@@ -1,5 +1,3 @@
-declare const CONSTANTS: {
-    [key: string]: string | Object;
-};
+declare const CONSTANTS: Record<string, any>;
 export { CONSTANTS };
 export default CONSTANTS;

package/build/lib/constants/index.js

@@ -90,102 +90,6 @@ const CONSTANTS = Object.freeze({
     PATTERN: {
         snake_case: 'snake_case',
         camelCase: 'camelCase'
-    },
-    DEFAULT: {
-        DEBUG: false,
-    },
-    DB: {
-        PRIMARY_KEY: 'id',
-        VOID: false,
-        RESULT: null,
-        DISTINCT: false,
-        PLUCK: '',
-        SAVE: '',
-        DELETE: '',
-        UPDATE: '',
-        INSERT: '',
-        SELECT: [],
-        ONLY: [],
-        EXCEPTS: [],
-        CHUNK: 0,
-        COUNT: '',
-        FROM: 'FROM',
-        JOIN: [],
-        WHERE: [],
-        GROUP_BY: '',
-        ORDER_BY: [],
-        LIMIT: '',
-        OFFSET: '',
-        HAVING: '',
-        TABLE_NAME: '',
-        UUID_CUSTOM: '',
-        HIDDEN: [],
-        DEBUG: false,
-        UUID: false,
-        PAGE: 1,
-        PER_PAGE: 1,
-        HOOKS: [],
-        RETURN_TYPE: null
-    },
-    MODEL: {
-        MODEL_NAME: 'MODEL',
-        PRIMARY_KEY: 'id',
-        VOID: false,
-        SELECT: [],
-        DELETE: '',
-        UPDATE: '',
-        INSERT: '',
-        ONLY: [],
-        EXCEPTS: [],
-        CHUNK: 0,
-        COUNT: '',
-        FROM: 'FROM',
-        JOIN: [],
-        WHERE: [],
-        GROUP_BY: '',
-        ORDER_BY: [],
-        LIMIT: '',
-        OFFSET: '',
-        HAVING: '',
-        TABLE_NAME: '',
-        UUID_FORMAT: 'uuid',
-        HIDDEN: [],
-        DEBUG: false,
-        UUID: false,
-        SOFT_DELETE: false,
-        SOFT_DELETE_FORMAT: 'deleted_at',
-        SOFT_DELETE_RELATIONS: false,
-        PAGE: 1,
-        PER_PAGE: 1,
-        REGISTRY: {},
-        RESULT: null,
-        PATTERN: 'snake_case',
-        DISTINCT: false,
-        PLUCK: '',
-        SAVE: '',
-        HOOKS: [],
-        RELATION: [],
-        RELATIONS: [],
-        RELATIONS_TRASHED: false,
-        RELATIONS_EXISTS: false,
-        RELATIONS_EXISTS_NOT_ID: [],
-        TIMESTAMP: false,
-        TIMESTAMP_FORMAT: {
-            CREATED_AT: 'created_at',
-            UPDATED_AT: 'updated_at'
-        },
-        LOGGER: false,
-        LOGGER_OPTIONS: null,
-        TABLE_LOGGER: '$loggers',
-        VALIDATE_SCHEMA: false,
-        VALIDATE_SCHEMA_DEFINED: null,
-        FUNCTION_RELATION: false,
-        SCHEMA_TABLE: null,
-        RETRY: 0,
-        OBSERVER: null,
-        DATA: null,
-        BEFORE_CREATING_TABLE: null,
-        RETURN_TYPE: null
     }
 });
 exports.CONSTANTS = CONSTANTS;

package/build/lib/core/Abstracts/AbstractBuilder.d.ts

@@ -117,7 +117,7 @@ declare abstract class AbstractBuilder {
     abstract save(): Promise<Record<string, any> | any[] | null | undefined>;
     abstract increment(column: string, value: number): Promise<number>;
     abstract decrement(column: string, value: number): Promise<number>;
-    abstract faker(round: number, cb?: Function): Promise<Record<string, any>[]>;
+    abstract faker(round: number, cb?: Function): Promise<void>;
 }
 export { AbstractBuilder };
 export default AbstractBuilder;

package/build/lib/core/Abstracts/AbstractBuilder.js

@@ -15,10 +15,7 @@ class AbstractBuilder {
         ];
         this.$utils = {};
         this.$constants = (name) => { };
-        this.$state = new State_1.StateHandler({
-            state: {},
-            constants: {}
-        });
+        this.$state = new State_1.StateHandler('default');
         this.$pool = {
             query: (sql) => { },
             set: (pool) => { },

package/build/lib/core/Abstracts/AbstractModel.d.ts

@@ -2,7 +2,8 @@ import { Pattern, Relation, RelationQuery, ValidateSchema } from '../../Interfac
 import { Blueprint } from '../Blueprint';
 import { Builder } from '../Builder';
 import { RelationHandler } from '../Handlers/Relation';
-declare abstract class AbstractModel<T> extends Builder {
+import { Model } from '../Model';
+declare abstract class AbstractModel<T, R> extends Builder {
     protected $relation: RelationHandler | undefined;
     protected $schema: Record<string, Blueprint> | undefined;
     protected $validateSchema: ValidateSchema | undefined;
@@ -48,7 +49,7 @@ declare abstract class AbstractModel<T> extends Builder {
     protected abstract hasMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
     protected abstract belongsTo({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
     protected abstract belongsToMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
-    protected abstract buildMethodRelation(name: string, callback?: Function): this;
+    protected abstract buildMethodRelation<K extends keyof R>(name: K, callback?: Function): this;
     protected abstract hasOneBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
     protected abstract hasManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
     protected abstract belongsToBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
@@ -59,17 +60,17 @@ declare abstract class AbstractModel<T> extends Builder {
     abstract onlyTrashed(): this;
     abstract trashed(): this;
     abstract restore(): Promise<any[]>;
-    abstract with(...nameRelations: string[]): this;
-    abstract withQuery(nameRelations: string, callback: Function): this;
-    abstract withExists(...nameRelations: string[]): this;
-    abstract withTrashed(...nameRelations: string[]): this;
-    abstract withAll(...nameRelations: string[]): this;
-    abstract has(...nameRelations: string[]): this;
-    abstract relations(...nameRelations: string[]): this;
-    abstract relationQuery(nameRelations: string, callback: Function): this;
-    abstract relationsExists(...nameRelations: string[]): this;
-    abstract relationsAll(...nameRelations: string[]): this;
-    abstract relationsTrashed(...nameRelations: string[]): this;
+    abstract with<K extends keyof R>(...nameRelations: K[]): this;
+    abstract withQuery<K extends keyof R, TModel extends Model>(nameRelations: K, callback: (query: TModel) => TModel): this;
+    abstract withExists<K extends keyof R>(...nameRelations: K[]): this;
+    abstract withTrashed<K extends keyof R>(...nameRelations: K[]): this;
+    abstract withAll<K extends keyof R>(...nameRelations: K[]): this;
+    abstract has<K extends keyof R>(...nameRelations: K[]): this;
+    abstract relations<K extends keyof R>(...nameRelations: K[]): this;
+    abstract relationQuery<K extends keyof R, TModel extends Model>(nameRelations: K, callback: (query: TModel) => TModel): this;
+    abstract relationsExists<K extends keyof R>(...nameRelations: K[]): this;
+    abstract relationsAll<K extends keyof R>(...nameRelations: K[]): this;
+    abstract relationsTrashed<K extends keyof R>(...nameRelations: K[]): this;
 }
 export { AbstractModel };
 export default AbstractModel;

package/build/lib/core/Builder.d.ts

@@ -1289,7 +1289,7 @@ declare class Builder extends AbstractBuilder {
      * @param {number} rows number of rows
      * @return {promise<any>}
      */
-    faker(rows: number, cb?: Function): Promise<Record<string, any>[]>;
+    faker(rows: number, cb?: Function): Promise<void>;
     /**
      *
      * truncate of table