taon 19.0.6 → 19.0.8

package/websql/lib/base-classes/base-angular-service.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { TaonContext } from '../create-context';
+import * as i0 from "@angular/core";
+/**
+ * TODO prevent calling methods when not initialized
+ * with init(ctx)
+ */
+export declare abstract class BaseAngularsService {
+    protected currentContext: TaonContext;
+    init(currentContext: TaonContext): void;
+    protected abstract initControllers(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseAngularsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseAngularsService>;
+}

package/websql/lib/base-classes/base-custom-repository.d.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import { BaseInjector } from './base-injector';
+export declare abstract class BaseCustomRepository extends BaseInjector {
+}

package/websql/lib/base-classes/base-entity.d.ts

@@ -1,8 +1,17 @@
 // @ts-nocheck
+import { RelationPath } from 'taon-typeorm/websql';
 import { BaseClass } from './base-class';
 export declare abstract class BaseEntity<
 /**
  * type for cloning
  */
 CloneT extends BaseClass = any> extends BaseClass<CloneT> {
+    /**
+     * simple check if relation is ok
+     */
+    relation(relationName: RelationPath<CloneT>): string;
+    /**
+     * simple check if relation is ok
+     */
+    relations(relationNames: RelationPath<CloneT>[]): string[];
 }

package/websql/lib/base-classes/base-injector.d.ts

@@ -1,7 +1,8 @@
 // @ts-nocheck
 import { EndpointContext } from '../endpoint-context';
-import type { BaseRepository } from './base-repository';
 import { BaseClass } from './base-class';
+import { BaseCustomRepository } from './base-custom-repository';
+import type { BaseRepository } from './base-repository';
 export declare class BaseInjector<CloneT extends BaseClass = any> {
     /**
      * for proxy purposes
@@ -29,14 +30,23 @@ export declare class BaseInjector<CloneT extends BaseClass = any> {
      * inject crud repo for entity
      */
     injectRepo<T>(entityForCrud: new (...args: any[]) => T): BaseRepository<T>;
-    injectCustomRepository<T>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    injectCustomRepository<T extends BaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    /**
+     * aliast to this.injectRepository()
+     */
+    injectCustomRepo<T extends BaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
     /**
-     * aliast to .injectRepository()
+     * example usage:
+     * ...
+     * exampleController = this.injectController(ExampleController);
+     * ...
      */
-    injectCustomRepo<T>(cutomRepositoryClass: new (...args: any[]) => T): T;
     injectController<T>(ctor: new (...args: any[]) => T): T;
     /**
-     * aliast to .injectController()
+     * example usage:
+     * ...
+     * exampleSubscriber = this.injectSubscriber(ExampleSubscriber)
+     * ...
      */
     injectSubscriber<T>(ctor: new (...args: any[]) => T): T;
     /**
@@ -52,10 +62,6 @@ export declare class BaseInjector<CloneT extends BaseClass = any> {
      * TODO
      */
     injectContextProvider<T>(ctor: new (...args: any[]) => T): T;
-    /**
-     * Repositories to init (by controller)
-     */
-    protected __repositories_to_init__: BaseRepository<any>[];
     /**
      * Inject: Controllers, Providers, Repositories, Services, etc.
      * TODO  addd nest js injecting

package/websql/lib/base-classes/base-repository.d.ts

@@ -1,20 +1,18 @@
 // @ts-nocheck
-import type { FindManyOptions, FindOneOptions, FindOptionsWhere, InsertResult, Repository, SaveOptions, UpdateResult } from 'taon-typeorm/websql';
-import type { QueryDeepPartialEntity } from 'taon-typeorm/lib/typeorm/query-builder/QueryPartialEntity';
-import type { UpsertOptions } from 'taon-typeorm/lib/typeorm/repository/UpsertOptions';
-import type { DataSource as DataSourceType } from 'taon-typeorm/websql';
+import { type DeepPartial, type FindManyOptions, type FindOneOptions, type FindOptionsWhere, type InsertResult, type Repository, type SaveOptions, type UpdateResult } from 'taon-typeorm/websql';
+import type { QueryDeepPartialEntity } from 'taon-typeorm/websql';
+import type { UpsertOptions } from 'taon-typeorm/websql';
+import type { DataSource as DataSourceType, QueryRunner, SelectQueryBuilder } from 'taon-typeorm/websql';
 import { MySqlQuerySource } from 'taon-type-sql/websql';
-import { BaseInjector } from './base-injector';
+import { BaseCustomRepository } from './base-custom-repository';
 export declare abstract class BaseRepository<Entity extends {
     id?: any;
-}> extends BaseInjector {
-    private __entityClassResolveFn;
+}> extends BaseCustomRepository {
     abstract entityClassResolveFn: () => any;
     constructor(__entityClassResolveFn: () => any);
     private __dbQuery;
     get dbQuery(): MySqlQuerySource;
     get connection(): DataSourceType;
-    private __repository;
     protected get repository(): Repository<Entity>;
     /**
      * target for repository
@@ -25,7 +23,6 @@ export declare abstract class BaseRepository<Entity extends {
      */
     protected get repo(): Repository<Entity>;
     get repositoryExists(): boolean;
-    __init(context?: any): Promise<void>;
     /**
      * Checks if entity has an id.
      * If entity composite compose ids, it will check them all.
@@ -47,9 +44,20 @@ export declare abstract class BaseRepository<Entity extends {
      * -> it will actuall create new entity in db
      * in oposite to typeorm create method
      */
-    create(item: Entity, options?: SaveOptions & {
-        reload: false;
-    }): Promise<Entity>;
+    /**
+     * Creates a new entity instance.
+     */
+    create(): Entity;
+    /**
+     * Creates new entities and copies all entity properties from given objects into their new entities.
+     * Note that it copies only properties that are present in entity schema.
+     */
+    create(entityLikeArray: DeepPartial<Entity>[]): Entity[];
+    /**
+     * Creates a new entity instance and copies all entity properties from this object into a new entity.
+     * Note that it copies only properties that are present in entity schema.
+     */
+    create(entityLike: DeepPartial<Entity>): Entity;
     bulkSave(items: Entity[], options?: SaveOptions & {
         reload: false;
     }): Promise<Entity[]>;
@@ -230,6 +238,11 @@ export declare abstract class BaseRepository<Entity extends {
      * Raw query execution is supported only by relational databases (MongoDB is not supported).
      */
     query(query: string, parameters?: any[]): Promise<any>;
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<Entity>;
     /**
      * Clears all the data from the given table/collection (truncates/drops it).
      *

package/websql/lib/base-classes/base.d.ts

@@ -1,13 +1,15 @@
 // @ts-nocheck
+import * as abstractEntity from './base-abstract-entity';
+import * as baseService from './base-angular-service';
+import * as baseClass from './base-class';
 import * as controller from './base-controller';
 import * as crudController from './base-crud-controller';
+import * as customRepository from './base-custom-repository';
 import * as entity from './base-entity';
-import * as abstractEntity from './base-abstract-entity';
-import * as repository from './base-repository';
+import * as baseMigration from './base-migration';
 import * as provider from './base-provider';
-import * as baseClass from './base-class';
+import * as repository from './base-repository';
 import * as baseSubscriberEntity from './base-subscriber-for-entity';
-import * as baseMigration from './base-migration';
 export declare namespace Base {
     export import Controller = controller.BaseController;
     export import CrudController = crudController.BaseCrudController;
@@ -17,8 +19,10 @@ export declare namespace Base {
     export import Provider = provider.BaseProvider;
     export import Class = baseClass.BaseClass;
     export import Repository = repository.BaseRepository;
+    export import CustomRepository = customRepository.BaseCustomRepository;
     export import SubscriberForEntity = baseSubscriberEntity.BaseSubscriberForEntity;
     export import Migration = baseMigration.BaseMigration;
+    export import AngularService = baseService.BaseAngularsService;
     const Context: {
         types: {
             readonly controllers: any;

package/websql/lib/create-context.d.ts

@@ -82,4 +82,5 @@ export declare const createContext: <CTX extends Record<string, object>, CTRL ex
         readonly client: import("./realtime/realtime-client").RealtimeClient;
         readonly server: import("./realtime/realtime-server").RealtimeServer;
     };
-};
+};
+export type TaonContext = ReturnType<typeof createContext>;

package/websql/lib/endpoint-context.d.ts

@@ -1,11 +1,12 @@
 // @ts-nocheck
-import { Models } from './models';
-import type { Application } from 'express';
+import type { Server } from 'http';
 import type { NgZone } from '@angular/core';
+import type { Application } from 'express';
+import type { Repository } from 'taon-typeorm/websql';
 import { DataSource } from 'taon-typeorm/websql';
-import type { Server } from 'http';
 import type { BaseClass } from './base-classes/base-class';
 import { ContextDbMigrations } from './context-db-migrations';
+import { Models } from './models';
 export declare class EndpointContext {
     private originalConfig;
     private configFn;
@@ -30,6 +31,7 @@ export declare class EndpointContext {
         routePath: string;
         method: Models.Http.Rest.HttpMethod;
     }[];
+    repos: Map<string, Repository<any>>;
     readonly skipWritingServerRoutes: boolean;
     private injectableTypesfromContexts;
     private allTypesfromContexts;
@@ -65,7 +67,7 @@ export declare class EndpointContext {
     }): Promise<void>;
     private getAutoGeneratedConfig;
     get ngZone(): any;
-    startServer(): any;
+    startServer(): Promise<void>;
     displayRoutes(app: any): void;
     get modeAllowsDatabaseCreation(): boolean;
     private cloneClassWithNewMetadata;
@@ -74,10 +76,11 @@ export declare class EndpointContext {
     private getRecrusiveClassesfromContexts;
     getClassInstanceObjBy(classType: Models.ClassType): any;
     private getClassesInstancesArrBy;
-    inject<T>(ctor: new (...args: any[]) => T, options?: {
+    inject<T>(ctor: new (...args: any[]) => T, options: {
         localInstance?: boolean;
         contextClassInstance?: BaseClass;
         locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;
+        parentInstanceThatWillGetInjectedStuff: object;
     }): T;
     /**
      * alias for inject

package/websql/lib/index.d.ts

@@ -1,27 +1,28 @@
 // @ts-nocheck
 import 'reflect-metadata';
-import * as http from './decorators/http/http-decorators';
+import { NgZone } from '@angular/core';
 import * as base from './base-classes/base';
 import * as controllerDecorator from './decorators/classes/controller-decorator';
 import * as entityDecorator from './decorators/classes/entity-decorator';
+import * as migrationDecorator from './decorators/classes/migration-decorator';
 import * as providerDecorator from './decorators/classes/provider-decorator';
 import * as repositoryDecorator from './decorators/classes/repository-decorator';
 import * as subscriberDecorator from './decorators/classes/subscriber-decorator';
-import * as migrationDecorator from './decorators/classes/migration-decorator';
-import * as orm from './orm';
-import * as models from './models';
+import * as http from './decorators/http/http-decorators';
 import * as endpointContext from './endpoint-context';
+import * as models from './models';
+import * as orm from './orm';
 import * as allSymbols from './symbols';
-import { NgZone } from '@angular/core';
 export * from './ui';
 export { EndpointContext } from './endpoint-context';
 export { BaseRepository } from './base-classes/base-repository';
+export { BaseCustomRepository } from './base-classes/base-custom-repository';
 export { BaseController } from './base-classes/base-controller';
 export { BaseProvider } from './base-classes/base-provider';
 export { BaseEntity } from './base-classes/base-entity';
 export { BaseContext } from './base-classes/base-context';
 export { BaseMigration } from './base-classes/base-migration';
-export { createContext } from './create-context';
+export { createContext, TaonContext } from './create-context';
 export { inject } from './inject';
 export { Models } from './models';
 export * from './constants';

package/websql/lib/orm.d.ts

@@ -28,18 +28,31 @@ export declare namespace Orm {
         export import UpdateDate = tsorm.UpdateDateColumn;
         export import DeleteDate = tsorm.DeleteDateColumn;
         export import Custom = tsorm.Column;
+        /**
+         * 100 default characters varchar
+         */
+        const String: <T = string>(defaultValue?: T, length?: number) => PropertyDecorator;
         /**
          * 100 characters varchar
          */
-        const String: <T = string>(defaultValue?: T) => PropertyDecorator;
+        const String100: <T = string>(defaultValue?: T) => PropertyDecorator;
+        /**
+         * 100 characters varchar
+         */
+        const String45: <T = string>(defaultValue?: T) => PropertyDecorator;
         /**
          * 500 characters varchar
          */
         const String500: <T = string>(defaultValue?: T) => PropertyDecorator;
+        /**
+         * 200 characters varchar
+         */
+        const String200: <T = string>(defaultValue?: T) => PropertyDecorator;
         const Number: () => PropertyDecorator;
         const DecimalNumber: () => PropertyDecorator;
         const SimpleJson: () => PropertyDecorator;
-        const Boolean: (defaultValue: boolean) => PropertyDecorator;
+        const Boolean: (defaultValue: boolean | null) => PropertyDecorator;
+        const DateTIme: (defaultValue?: boolean | null) => PropertyDecorator;
         export import Version = tsorm.VersionColumn;
         export import Virtual = tsorm.VirtualColumn;
     }

package/websql/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon/websql",
-  "version": "19.0.6",
+  "version": "19.0.8",
   "module": "fesm2022/taon.mjs",
   "typings": "index.d.ts",
   "exports": {