feat: allow non singleton factories

lib/compiler/compiler.ts

@@ -155,7 +155,27 @@ export class Compiler {
         await Promise.all(
           unit.members.map(async member => {
             if (ts.isMethodDeclaration(member)) {
-              if (hasDecorator('provides', member)) {
+              const provides = getDecorator('provides', member);
+              if (provides) {
+                // -- is singleton?
+                const singleton = (() => {
+                  const parameters = getDecoratorParameters(provides);
+                  if (parameters.length > 0) {
+                    const config = parameters[0];
+                    if (!ts.isObjectLiteralExpression(config)) {
+                      throw new Error('Invalid @provides decorator');
+                    }
+
+                    const singleton = getValueFromObjectLiteral(
+                      config,
+                      'singleton'
+                    );
+                    return singleton.kind !== ts.SyntaxKind.FalseKeyword;
+                  }
+                  return true;
+                })();
+                // /- is singleton?
+
                 const parameterTypes = await this.getMethodParameterTypes(
                   member
                 );
@@ -169,7 +189,9 @@ export class Compiler {
                     type: returnType,
                     constructorDependencies: [],
                     propertyDependencies: [],
-                    meta: {}
+                    meta: {
+                      singleton
+                    }
                   };
                   components.set(returnType, component);
                 }

lib/compiler/decorators.ts

@@ -10,12 +10,12 @@ export function managed(
   //
 }
 
-export function meta(): ClassDecorator {
+export function meta(_options: { singleton?: boolean }): ClassDecorator {
   return () => undefined;
 }
 
-export function provides(_target: any, _prop: any): void {
-  //
+export function provides(_option?: { singleton?: boolean }): MethodDecorator {
+  return () => undefined;
 }
 
 export function unit(_target: any): void {

lib/compiler/generator.ts

@@ -90,7 +90,11 @@ export class Generator {
                   }
                   let provider = '';
                   const meta = `{
-                    singleton: ${Boolean(component.meta.singleton)}
+                    singleton: ${
+                      typeof component.meta.singleton === 'boolean'
+                        ? component.meta.singleton
+                        : true
+                    }
                   }`;
                   if (component.provider) {
                     provider = `

tests/compiler/compiler.test.ts

@@ -180,4 +180,36 @@ describe('TSDI compiler', () => {
 
     await testContainer(code, files, expect);
   });
+
+  it('supports factories which produces non singletons', async () => {
+    const files = {
+      '/file.ts': `
+        import { container, unit, provides } from '/decorators';
+
+        export class Entry {
+        }
+
+        @unit
+        export class Unit {
+          @provides({singleton: false})
+          public entry(): Entry {
+            return new Entry();
+          }
+        }
+
+        @container({ units: [Unit] })
+        export abstract class Container {
+          public abstract entry: Entry;
+
+          public test(expect): void {
+            expect(this.entry).not.toBe(this.entry);
+          }
+        }
+      `
+    };
+
+    const code = await runCompiler(files);
+
+    await testContainer(code, files, expect);
+  });
 });