@tstdl/base 0.86.0-beta8 → 0.86.0

package/injector/injector.js

@@ -237,7 +237,7 @@ class Injector {
         return registration.resolutions.get(argumentIdentity);
       }
       const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
-      const resolution = { tag: resolutionTag, registration, value, argument, chain };
+      const resolution = { tag: resolutionTag, registration, value, argument: injectionContext.argument, chain };
       context.resolutions.push(resolution);
       if (resolutionScoped) {
         context.resolutionScopedResolutions.setFlat(token, argumentIdentity, resolution);
@@ -478,7 +478,7 @@ function throwOnPromise(value, type, chain) {
   }
 }
 function checkOverflow(chain, context) {
-  if (chain.length > 750 || ++context.resolves > 750) {
+  if (chain.length > 100 || ++context.resolves > 7500) {
     throw new import_resolve_error.ResolveError("Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle or forwardRef instead.", chain);
   }
 }

package/module/modules/web-server.module.js

@@ -24,7 +24,6 @@ __export(web_server_module_exports, {
 });
 module.exports = __toCommonJS(web_server_module_exports);
 var import_server = require("../../api/server/index.js");
-var import_log = require("../../decorators/log.js");
 var import_disposable = require("../../disposable/disposable.js");
 var import_http_server = require("../../http/server/http-server.js");
 var import_decorators = require("../../injector/decorators.js");
@@ -87,7 +86,6 @@ let WebServerModule = class WebServerModule2 extends import_module_base.ModuleBa
 };
 WebServerModule = __decorate([
   (0, import_decorators.Singleton)({ defaultArgumentProvider: () => webServerModuleConfiguration }),
-  (0, import_log.Log)(),
   __metadata("design:paramtypes", [])
 ], WebServerModule);
 function configureWebServerModule(config) {

package/object-storage/object-storage-provider.d.ts

@@ -4,5 +4,5 @@ export declare abstract class ObjectStorageProvider<T extends ObjectStorage = Ob
      * get an object storage instance
      * @param module name for object container (module) to store objects in. Can be used to isolate objects like profile pictures and log files
      */
-    abstract get(module: string): T | Promise<T>;
+    abstract get(module: string): T;
 }

package/object-storage/s3/s3.object-storage-provider.d.ts

@@ -17,10 +17,6 @@ export declare class S3ObjectStorageProviderConfig {
      * mutually exclusive with bucket
      */
     bucketPerModule?: boolean;
-    /**
-     * create bucket for requested storage module if it does not exist
-     */
-    autoCreateBucket?: boolean;
     /**
      * s3 access key
      */
@@ -34,9 +30,8 @@ export declare const bucketPerModule: unique symbol;
 export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3ObjectStorage> {
     private readonly client;
     private readonly bucket;
-    private readonly createBucket;
     constructor(config: S3ObjectStorageProviderConfig);
-    get(module: string): Promise<S3ObjectStorage>;
+    get(module: string): S3ObjectStorage;
 }
 /**
  * configure s3 object storage provider

package/object-storage/s3/s3.object-storage-provider.js

@@ -61,10 +61,6 @@ class S3ObjectStorageProviderConfig {
    * mutually exclusive with bucket
    */
   bucketPerModule;
-  /**
-   * create bucket for requested storage module if it does not exist
-   */
-  autoCreateBucket;
   /**
    * s3 access key
    */
@@ -78,14 +74,12 @@ const bucketPerModule = Symbol("bucket per module");
 let S3ObjectStorageProvider = class S3ObjectStorageProvider2 extends import_object_storage.ObjectStorageProvider {
   client;
   bucket;
-  createBucket;
   constructor(config) {
     super();
     const { hostname, port, protocol } = new URL(config.endpoint);
     if ((0, import_type_guards.isDefined)(config.bucket) && config.bucketPerModule == true) {
       throw new Error("bucket and bucketPerModule is mutually exclusive");
     }
-    this.createBucket = config.autoCreateBucket ?? false;
     this.client = new import_minio.Client({
       endPoint: hostname,
       port: port.length > 0 ? parseInt(port, 10) : void 0,
@@ -95,14 +89,10 @@ let S3ObjectStorageProvider = class S3ObjectStorageProvider2 extends import_obje
     });
     this.bucket = (0, import_type_guards.assertDefinedPass)(config.bucketPerModule == true ? true : config.bucket, "either bucket or bucketPerModule must be specified");
   }
-  async get(module2) {
+  get(module2) {
     const bucket = this.bucket == true ? module2 : (0, import_type_guards.assertStringPass)(this.bucket);
     const prefix = this.bucket == true ? "" : module2 == "" ? "" : `${module2}/`;
-    const objectStorage = new import_s3_object_storage.S3ObjectStorage(this.client, bucket, module2, prefix);
-    if (this.createBucket) {
-      await objectStorage.ensureBucketExists();
-    }
-    return objectStorage;
+    return new import_s3_object_storage.S3ObjectStorage(this.client, bucket, module2, prefix);
   }
 };
 S3ObjectStorageProvider = __decorate([

package/object-storage/s3/s3.object-storage.js

@@ -152,7 +152,10 @@ let S3ObjectStorage = class S3ObjectStorage2 extends import_object_storage.Objec
 S3ObjectStorage = __decorate([
   (0, import_decorators.Singleton)({
     provider: {
-      useFactory: async (argument, context) => context.resolve(import_s3_object_storage_provider.S3ObjectStorageProvider).get((0, import_type_guards.assertStringPass)(argument, "resolve argument must be a string (object storage module)"))
+      useFactory: (argument, context) => context.resolve(import_s3_object_storage_provider.S3ObjectStorageProvider).get((0, import_type_guards.assertStringPass)(argument, "resolve argument must be a string (object storage module)")),
+      async afterResolve(value) {
+        await value.ensureBucketExists();
+      }
     }
   }),
   __metadata("design:paramtypes", [import_minio.Client, String, String, String])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.86.0-beta8",
+  "version": "0.86.0",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -47,7 +47,7 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.9",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.85",
+    "@tstdl/angular": "^0.86",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",

package/_container/container.d.ts

@@ -1,99 +0,0 @@
-import type { Record, TypedOmit } from '../types.js';
-import type { Observable } from 'rxjs';
-import type { Injectable, InjectableArgument } from './interfaces.js';
-import type { Provider } from './provider.js';
-import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, Mapper } from './types.js';
-export declare const injectMetadataSymbol: unique symbol;
-/**
- * transient: a new instance will be created with each resolve
- * singleton: each resolve will return the same instance
- * resolution: the same instance will be resolved for each resolution of this dependency during a single resolution chain
- */
-export type Lifecycle = 'transient' | 'singleton' | 'resolution';
-export type RegistrationOptions<T, A = unknown> = {
-    lifecycle?: Lifecycle;
-    /** default resolve argument used when neither token nor explicit resolve argument is provided */
-    defaultArgument?: InjectableArgument<T, A>;
-    /** default resolve argument used when neither token nor explicit resolve argument is provided */
-    defaultArgumentProvider?: ArgumentProvider<InjectableArgument<T, A>>;
-    /**
-     * value to distinguish scoped and singleton instances based on argument
-     * by default it uses strict equality (===) on the original argument,
-     * so modifications to argument objects and literal objects in the call
-     * may not yield the expected result
-     *
-     * hint: {@link JSON.stringify} is a simple solution for many use cases,
-     * but will fail if properties have different order
-     */
-    argumentIdentityProvider?: Mapper<InjectableArgument<T, A> | undefined>;
-    /** function which gets called after a resolve */
-    initializer?: (instance: T) => any;
-    /** custom metadata */
-    metadata?: Record;
-};
-export type Registration<T = any, A = any> = {
-    token: InjectionToken<T, A>;
-    provider: Provider<T, A>;
-    options: RegistrationOptions<T, A>;
-    instances: Map<any, T>;
-};
-export declare class Container {
-    private readonly registrationMap;
-    private readonly registrationSubject;
-    /** emits on new registration */
-    readonly registration$: Observable<Registration>;
-    /** all registrations */
-    get registrations(): Iterable<Registration>;
-    constructor();
-    /**
-     * register a provider for a token
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    register<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
-    /**
-     * register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    registerSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
-    /**
-     * check if token has a registered provider
-     * @param token token check
-     */
-    hasRegistration(token: InjectionToken): boolean;
-    /**
-     * get registration
-     * @param token token to get registration for
-     */
-    getRegistration<T, A>(token: InjectionToken<T, A>): Registration<T, A>;
-    /**
-     * try to get registration
-     * @param token token to get registration for
-     */
-    tryGetRegistration<T, A>(token: InjectionToken<T, A>): Registration<T, A> | undefined;
-    /**
-     * resolve a token
-     * @param token token to resolve
-     * @param argument argument used for resolving (overrides token and default arguments)
-     * @returns
-     */
-    resolve<T, A = T extends Injectable<infer AInject> ? AInject : any>(token: InjectionToken<T, A>, argument?: T extends Injectable<infer AInject> ? AInject : A, instances?: [InjectionToken, any][]): T;
-    /**
-     * resolve a token
-     * @param token token to resolve
-     * @param argument argument used for resolving (overrides token and default arguments)
-     * @returns
-     */
-    resolveAsync<T, A = T extends Injectable<infer AInject> ? AInject : any>(token: InjectionToken<T, A>, argument?: T extends Injectable<infer AInject> ? AInject : A, instances?: [InjectionToken, any][]): Promise<T>;
-    private _resolve;
-    private _resolveAsync;
-    private resolveInjection;
-    private resolveInjectionAsync;
-    private getResolveContext;
-    private addInstancesToResolveContext;
-}
-export declare const container: Container;