Programatic Configuration: @Configuration class decorator

[nestjs]

Programatic Configuration: @Configuration class decorator

[thomrick]

I started to work on @configuration
For now I have something like this:
Decorator:

import 'reflect-metadata';
import {ConfigurationMetadata} from '../../interfaces/configuration-metadata.interface';
import {isNil, isObject} from '../shared.utils';
import {FILE_METADATA, IN_MEMORY_METADATA, URL_METADATA} from '../../constants';

export const Configuration = (metadata?: ConfigurationMetadata): ClassDecorator => {
  return isObject(metadata) ? ConfigurationFrom(metadata) : InMemoryConfiguration();
};

const InMemoryConfiguration = (): ClassDecorator => {
  return (target: object) => {
    Reflect.defineMetadata(IN_MEMORY_METADATA, true, target);
  }
};

const ConfigurationFrom = (metadata: ConfigurationMetadata): ClassDecorator => {
  if (!isNil(metadata.file))
    return FileConfiguration(metadata.file);
  else if (!isNil(metadata.url))
    return RemoteConfiguration(metadata.url);
};

const FileConfiguration = (filename: string): ClassDecorator => {
  return (target: object) => {
    Reflect.defineMetadata(FILE_METADATA, filename, target);
  }
};

const RemoteConfiguration = (url: string): ClassDecorator => {
  return (target: object) => {
    Reflect.defineMetadata(URL_METADATA, url, target);
  }
};

Helper classes:

export interface IConfiguration {
  getProperty(name: string): string;
}

export abstract class AbstractConfiguration implements IConfiguration {
  constructor(protected properties: {[key: string]: string} = {}) {}
  public getProperty(name: string): string {
    return this.properties[name];
  }
}

export abstract class AbstractInMemoryConfiguration extends AbstractConfiguration{
  constructor() {
    super();
    this.declare();
  }
  protected abstract declare(): void;
}

And a use case:

class TestConfiguration extends AbstractInMemoryConfiguration {
    protected declare(): void {
      this.properties['KEY'] = 'VALUE';
    }
  }

Regarding the @configuration decorator I can declare it like this:

@Configuration()
class TestConfiguration extends AbstractInMemoryConfiguration {  }

@Configuration(file: 'filename')
class TestConfiguration extends AbstractFileConfiguration {  }

@Configuration(url: 'http://domain/path')
class TestConfiguration extends AbstractRemoteConfiguration {  }

Does it seem to be good for you guys ?

[kamilmysliwiec]

Are you sure we really need the abstraction layer over configuration stuff? I think now it's easy to fetch the remote configuration / load config using fs package just before creating the Nest instance. If the configuration affects components and should be a part of the DI container - just use async components. What @thomrick proposed looks really good, but I'm trying to keep in mind that learning curve is already big enough 😃

[kamilmysliwiec]

Hi @thomrick,
Thank you so much for the invested time, but I just don't want to exaggerate. Maybe in the future, but not now 🙂 Kamil

[cojack]

@kamilmysliwiec could you leave it open? It's very nice feature.

[cojack]

You convinced me.

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.