itlab-internal-services 0.0.1

package/README.md

@@ -0,0 +1,206 @@
+# IT Lab Internal Services
+> Diese Library funktioniert nur mit NestJs
+
+[![npm version](https://img.shields.io/npm/v/itlab-internal-services.svg?style=flat-square)](https://www.npmjs.org/package/itlab-internal-services)
+[![install size](https://packagephobia.now.sh/badge?p=itlab-internal-services)](https://packagephobia.now.sh/result?p=itlab-internal-services)
+[![npm downloads](https://img.shields.io/npm/dm/itlab-internal-services.svg?style=flat-square)](http://npm-stat.com/charts.html?package=itlab-internal-services)
+[![jsdelivr](https://data.jsdelivr.com/v1/package/npm/itlab-internal-services/badge?style=rounded)](https://www.jsdelivr.com/package/npm/itlab-internal-services)
+
+## Internal module
+
+[Axios](https://github.com/axios/axios) is richly featured HTTP client package that is widely used. This package wraps Axios and exposes it via the built-in `InternalModule`. The `InternalModule` exports the `CommentService`, `ContentService` & `SearchService` classes, which exposes methods to perform HTTP requests to IT Labs internal services.
+
+### Installation
+
+To begin using it, we first install the required dependency.
+
+```bash
+yarn add itlab-internal-services
+```
+
+### Getting started
+
+Once the installation process is complete, to use the `InternalServices`, first import `InternalModule`.
+
+```typescript
+@Module({
+  imports: [InternalModule],
+  providers: [NewsService],
+})
+export class NewsModule {}
+```
+
+Next, inject `CommentService`, `ContentService` or `SearchService` using normal constructor injection.
+
+> **Hint** `InternalModule`, `CommentService`, `ContentService` & `SearchService` are imported from `itlab-internal-services` package.
+
+```typescript
+@Injectable()
+export class NewsService {
+  constructor(
+    private readonly commentService: CommentService,
+    private readonly contentService: ContentService,
+    private readonly searchService: SearchService,
+  ) {}
+}
+```
+
+### Comment Service
+```typescript
+async post(targetId: string, authorId: string, comment: Comment): Promise<Comment>
+```
+
+```typescript
+async delete(targetId: string): Promise<void>
+```
+
+### Content Service
+
+```typescript
+async verify(contents: Content[]): Promise<void>
+```
+
+```typescript
+async post(targetId: string, contents: Content[]): Promise<void>
+```
+
+```typescript
+async delete(targetId: string): Promise<void>
+```
+
+### Pipes
+```typescript
+@Controller("news")
+export class NewsController {
+
+  @ApiTarget("target")
+  @Get(":target")
+  getNews(@Target("target") target: string) {}
+
+}
+```
+
+```typescript
+@Controller("news")
+export class NewsController {
+
+  @ApiHid("hid")
+  @Get(":hid")
+  getNews(@Hid("hid") hid: string) {}
+
+}
+```
+
+```typescript
+@Controller("news")
+export class NewsController {
+
+  @ApiId("id")
+  @Get(":id")
+  getNews(@Id("id") id: string) {}
+
+}
+```
+
+### Guards
+```typescript
+@Internal()
+@Controller()
+export class NewsController {}
+```
+
+```typescript
+@Jwt()
+@Controller()
+export class NewsController {
+  @Get("")
+  getNews(@Account() account: LAccount) {}
+
+  @Get("")
+  getNews(@AccountId() accountId: string) {}
+
+  @Perms("perms.get", "perms.list")
+  @Get("")
+  getNews(@AccountId() accountId: string, @AccountPerms() accountPerms: string[]) {}
+}
+```
+
+### Configuration
+
+To configure the underlying service instance, pass an optional options object to the `register()` method of `InternalModule` when importing it. This options object will be passed directly to the underlying service constructor.
+
+```typescript
+@Module({
+  imports: [
+    InternalModule.register({
+      target: Targets.NEWSROOM,
+      token: 'itlab token',
+      jwt_secret: 'secret',
+    }),
+  ],
+  providers: [NewsService],
+})
+export class NewsModule {}
+```
+
+### Async configuration
+
+When you need to pass module options asynchronously instead of statically, use the `registerAsync()` method. As with most dynamic modules, this package provides several techniques to deal with async configuration.
+
+One technique is to use a factory function:
+
+```typescript
+InternalModule.registerAsync({
+  useFactory: () => ({
+    target: Targets.NEWSROOM,
+    token: 'itlab token',
+    jwt_secret: 'secret',
+  }),
+});
+```
+
+Like other factory providers, our factory function can be [async](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory) and can inject dependencies through `inject`.
+
+```typescript
+InternalModule.registerAsync({
+  imports: [ConfigModule],
+  useFactory: (configService: ConfigService) => ({
+    target: Targets.NEWSROOM,
+    token: configService.get<string>('K8S_TOKEN'),
+    jwt_secret: configService.get<string>('JWT_SECRET'),
+  }),
+  inject: [ConfigService],
+});
+```
+
+Alternatively, you can configure the `InternalModule` using a class instead of a factory, as shown below.
+
+```typescript
+InternalModule.registerAsync({
+  useClass: InternalConfigService,
+});
+```
+
+The construction above instantiates `InternalConfigService` inside `InternalModule`, using it to create an options object. Note that in this example, the `InternalConfigService` has to implement `InternalModuleOptionsFactory` interface as shown below. The `InternalModule` will call the `createInternalOptions()` method on the instantiated object of the supplied class.
+
+```typescript
+@Injectable()
+class InternalConfigService implements InternalModuleOptionsFactory {
+  createInternalOptions(): InternalModuleOptions {
+    return {
+      target: Targets.NEWSROOM,
+      token: 'itlab token',
+      jwt_secret: 'secret',
+    };
+  }
+}
+```
+
+If you want to reuse an existing options provider instead of creating a private copy inside the `InternalModule`, use the `useExisting` syntax.
+
+```typescript
+InternalModule.registerAsync({
+  imports: [ConfigModule],
+  useExisting: InternalConfigService,
+});
+```

package/dist/guards/index.d.ts

@@ -0,0 +1,3 @@
+export * from './internal.guard';
+export * from './jwt.guard';
+export * from './perms.guard';

package/dist/guards/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./internal.guard"), exports);
+__exportStar(require("./jwt.guard"), exports);
+__exportStar(require("./perms.guard"), exports);

package/dist/guards/internal.guard.d.ts

@@ -0,0 +1,11 @@
+import { CanActivate, ExecutionContext, HttpException } from '@nestjs/common';
+export declare const INTERNAL_HEADER_KEY = "X-itlab-k8s-auth";
+export declare class InternalGuard implements CanActivate {
+    protected readonly headerToken: string;
+    constructor(headerToken?: string);
+    canActivate(ctx: ExecutionContext): boolean;
+}
+export declare class UnauthorizedApplicationException extends HttpException {
+    constructor();
+}
+export declare const Internal: <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/guards/internal.guard.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Internal = exports.UnauthorizedApplicationException = exports.InternalGuard = exports.INTERNAL_HEADER_KEY = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const internal_constants_1 = require("../internal.constants");
+exports.INTERNAL_HEADER_KEY = 'X-itlab-k8s-auth';
+let InternalGuard = class InternalGuard {
+    constructor(headerToken = '') {
+        this.headerToken = headerToken;
+    }
+    canActivate(ctx) {
+        if (this.headerToken.length === 0)
+            return false;
+        if (this.headerToken ===
+            ctx.switchToHttp().getRequest().header(exports.INTERNAL_HEADER_KEY))
+            return true;
+        throw new UnauthorizedApplicationException();
+    }
+};
+InternalGuard = __decorate([
+    __param(0, (0, common_1.Inject)(internal_constants_1.INTERNAL_MODULE_HEADER_TOKEN)),
+    __metadata("design:paramtypes", [String])
+], InternalGuard);
+exports.InternalGuard = InternalGuard;
+class UnauthorizedApplicationException extends common_1.HttpException {
+    constructor() {
+        super('Application unauthorized', common_1.HttpStatus.UNAUTHORIZED);
+    }
+}
+exports.UnauthorizedApplicationException = UnauthorizedApplicationException;
+exports.Internal = (0, common_1.applyDecorators)((0, swagger_1.ApiBasicAuth)(exports.INTERNAL_HEADER_KEY), (0, common_1.UseGuards)(InternalGuard), (0, swagger_1.ApiUnauthorizedResponse)({ description: 'Application unauthorized' }));

package/dist/guards/jwt.guard.d.ts

@@ -0,0 +1,19 @@
+export interface LAccount {
+    id: string;
+    perms: string[];
+}
+declare const JwtStrategy_base: new (...args: any[]) => any;
+export declare class JwtStrategy extends JwtStrategy_base {
+    protected readonly jwtSecret: string;
+    constructor(jwtSecret?: string);
+    validate(payload: any): LAccount;
+}
+export declare const Account: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const AccountId: ParameterDecorator;
+export declare const AccountPerms: ParameterDecorator;
+export declare const JwtToken: (...dataOrPipes: any[]) => ParameterDecorator;
+declare const JwtGuard_base: import("@nestjs/passport").Type<import("@nestjs/passport").IAuthGuard>;
+export declare class JwtGuard extends JwtGuard_base {
+}
+export declare const Jwt: <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export {};

package/dist/guards/jwt.guard.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jwt = exports.JwtGuard = exports.JwtToken = exports.AccountPerms = exports.AccountId = exports.Account = exports.JwtStrategy = void 0;
+const common_1 = require("@nestjs/common");
+const passport_1 = require("@nestjs/passport");
+const swagger_1 = require("@nestjs/swagger");
+const passport_jwt_1 = require("passport-jwt");
+const internal_constants_1 = require("../internal.constants");
+let JwtStrategy = class JwtStrategy extends (0, passport_1.PassportStrategy)(passport_jwt_1.Strategy, 'jwt') {
+    constructor(jwtSecret = 'unknown') {
+        super({
+            jwtFromRequest: passport_jwt_1.ExtractJwt.fromAuthHeaderAsBearerToken(),
+            secretOrKey: jwtSecret,
+        });
+        this.jwtSecret = jwtSecret;
+    }
+    validate(payload) {
+        return { id: payload.id, perms: payload.perms || [] };
+    }
+};
+JwtStrategy = __decorate([
+    __param(0, (0, common_1.Inject)(internal_constants_1.INTERNAL_MODULE_JWT_SECRET)),
+    __metadata("design:paramtypes", [String])
+], JwtStrategy);
+exports.JwtStrategy = JwtStrategy;
+exports.Account = (0, common_1.createParamDecorator)((param, ctx) => {
+    const { user } = ctx.switchToHttp().getRequest();
+    return param ? user === null || user === void 0 ? void 0 : user[param] : user;
+});
+exports.AccountId = (0, exports.Account)('id');
+exports.AccountPerms = (0, exports.Account)('perms');
+exports.JwtToken = (0, common_1.createParamDecorator)((_, ctx) => {
+    const h = ctx.switchToHttp().getRequest().header('Authorization');
+    return h.replace('Bearer ', '');
+});
+class JwtGuard extends (0, passport_1.AuthGuard)('jwt') {
+}
+exports.JwtGuard = JwtGuard;
+exports.Jwt = (0, common_1.applyDecorators)((0, common_1.UseGuards)(JwtGuard), (0, swagger_1.ApiBearerAuth)(), (0, swagger_1.ApiUnauthorizedResponse)({ description: 'Unauthorized' }));

package/dist/guards/perms.guard.d.ts

@@ -0,0 +1,11 @@
+import { CanActivate, ExecutionContext, HttpException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+export declare class PermsGuard implements CanActivate {
+    private readonly reflector;
+    constructor(reflector: Reflector);
+    canActivate(ctx: ExecutionContext): boolean;
+}
+export declare class InsufficientPermissionsException extends HttpException {
+    constructor();
+}
+export declare function Perms(...perms: string[]): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/guards/perms.guard.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Perms = exports.InsufficientPermissionsException = exports.PermsGuard = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const jwt_guard_1 = require("./jwt.guard");
+const meta = 'permsguard';
+function transformPermissions(permissions) {
+    const mapped = permissions.map((p) => {
+        return [p, p.split('.').slice(0, -1).join('.') + '.*'];
+    });
+    return [...new Set(mapped.flat())];
+}
+class PermsGuard {
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    canActivate(ctx) {
+        let perms = this.reflector.get(meta, ctx.getHandler());
+        if (!perms || !perms.length || perms.length === 0) {
+            return true;
+        }
+        perms = transformPermissions(perms);
+        const { user } = ctx.switchToHttp().getRequest();
+        let userPerms = user.perms;
+        if (userPerms.length === 0)
+            throw new InsufficientPermissionsException();
+        userPerms = userPerms.map((x) => x.toLowerCase());
+        if (perms.some((p) => userPerms.includes(p.toLowerCase())))
+            return true;
+        throw new InsufficientPermissionsException();
+    }
+}
+exports.PermsGuard = PermsGuard;
+class InsufficientPermissionsException extends common_1.HttpException {
+    constructor() {
+        super('Insufficient permissions', common_1.HttpStatus.UNAUTHORIZED);
+    }
+}
+exports.InsufficientPermissionsException = InsufficientPermissionsException;
+function Perms(...perms) {
+    return (0, common_1.applyDecorators)((0, common_1.SetMetadata)(meta, perms), (0, common_1.UseGuards)(jwt_guard_1.JwtGuard, PermsGuard), (0, swagger_1.ApiBearerAuth)(), (0, swagger_1.ApiOperation)({ summary: 'Perms: ' + perms.join(', ') }), (0, swagger_1.ApiUnauthorizedResponse)({
+        description: 'Unauthorized or insufficient permissions',
+    }));
+}
+exports.Perms = Perms;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './guards';
+export * from './interfaces';
+export * from './internal.module';
+export * from './pipes';
+export * from './services';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./guards"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./internal.module"), exports);
+__exportStar(require("./pipes"), exports);
+__exportStar(require("./services"), exports);

package/dist/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './internal-module.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./internal-module.interface"), exports);

package/dist/interfaces/internal-module.interface.d.ts

@@ -0,0 +1,17 @@
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
+import { Targets } from '../pipes/target.pipe';
+export declare type InternalModuleOptions = {
+    jwt_secret: string;
+    token: string;
+    target: Targets;
+};
+export interface InternalModuleOptionsFactory {
+    createInternalOptions(): Promise<InternalModuleOptions> | InternalModuleOptions;
+}
+export interface InternalModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<InternalModuleOptionsFactory>;
+    useClass?: Type<InternalModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<InternalModuleOptions> | InternalModuleOptions;
+    inject?: any[];
+    extraProviders?: Provider[];
+}

package/dist/interfaces/internal-module.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal.constants.d.ts

@@ -0,0 +1,6 @@
+export declare const AXIOS_INSTANCE_TOKEN = "AXIOS_INSTANCE_TOKEN";
+export declare const INTERNAL_MODULE_ID = "INTERNAL_MODULE_ID";
+export declare const INTERNAL_MODULE_OPTIONS = "INTERNAL_MODULE_OPTIONS";
+export declare const INTERNAL_MODULE_TARGET = "INTERNAL_MODULE_TARGET";
+export declare const INTERNAL_MODULE_JWT_SECRET = "INTERNAL_MODULE_JWT_SECRET";
+export declare const INTERNAL_MODULE_HEADER_TOKEN = "INTERNAL_MODULE_HEADER_TOKEN";

package/dist/internal.constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERNAL_MODULE_HEADER_TOKEN = exports.INTERNAL_MODULE_JWT_SECRET = exports.INTERNAL_MODULE_TARGET = exports.INTERNAL_MODULE_OPTIONS = exports.INTERNAL_MODULE_ID = exports.AXIOS_INSTANCE_TOKEN = void 0;
+exports.AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
+exports.INTERNAL_MODULE_ID = 'INTERNAL_MODULE_ID';
+exports.INTERNAL_MODULE_OPTIONS = 'INTERNAL_MODULE_OPTIONS';
+exports.INTERNAL_MODULE_TARGET = 'INTERNAL_MODULE_TARGET';
+exports.INTERNAL_MODULE_JWT_SECRET = 'INTERNAL_MODULE_JWT_SECRET';
+exports.INTERNAL_MODULE_HEADER_TOKEN = 'INTERNAL_MODULE_HEADER_TOKEN';

package/dist/internal.module.d.ts

@@ -0,0 +1,10 @@
+import { DynamicModule } from '@nestjs/common';
+import { InternalModuleAsyncOptions, InternalModuleOptions } from './interfaces';
+export declare class InternalModule {
+    static register(options: InternalModuleOptions): DynamicModule;
+    static registerAsync(options: InternalModuleAsyncOptions): DynamicModule;
+    static forRoot(options: InternalModuleOptions): DynamicModule;
+    static forRootAsync(options: InternalModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/internal.module.js

@@ -0,0 +1,126 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var InternalModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalModule = void 0;
+const common_1 = require("@nestjs/common");
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const axios_1 = __importDefault(require("axios"));
+const internal_constants_1 = require("./internal.constants");
+const services_1 = require("./services");
+const axiosConfig = (config) => ({
+    baseURL: 'https://services.svi-itlab.com/',
+    headers: { 'X-itlab-k8s-auth': config.token },
+});
+let InternalModule = InternalModule_1 = class InternalModule {
+    static register(options) {
+        return {
+            module: InternalModule_1,
+            providers: [
+                {
+                    provide: internal_constants_1.AXIOS_INSTANCE_TOKEN,
+                    useValue: axios_1.default.create(axiosConfig(options)),
+                },
+                { provide: internal_constants_1.INTERNAL_MODULE_ID, useValue: (0, random_string_generator_util_1.randomStringGenerator)() },
+                { provide: internal_constants_1.INTERNAL_MODULE_TARGET, useValue: options.target },
+                { provide: internal_constants_1.INTERNAL_MODULE_HEADER_TOKEN, useValue: options.token },
+                { provide: internal_constants_1.INTERNAL_MODULE_JWT_SECRET, useValue: options.jwt_secret },
+            ],
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: InternalModule_1,
+            imports: options.imports,
+            providers: [
+                ...this.createAsyncProviders(options),
+                {
+                    provide: internal_constants_1.AXIOS_INSTANCE_TOKEN,
+                    useFactory: (config) => axios_1.default.create(axiosConfig(config)),
+                    inject: [internal_constants_1.INTERNAL_MODULE_OPTIONS],
+                },
+                {
+                    provide: internal_constants_1.INTERNAL_MODULE_ID,
+                    useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                },
+                {
+                    provide: internal_constants_1.INTERNAL_MODULE_TARGET,
+                    useFactory: (config) => config.target,
+                    inject: [internal_constants_1.INTERNAL_MODULE_OPTIONS],
+                },
+                {
+                    provide: internal_constants_1.INTERNAL_MODULE_HEADER_TOKEN,
+                    useFactory: (config) => config.token,
+                    inject: [internal_constants_1.INTERNAL_MODULE_OPTIONS],
+                },
+                {
+                    provide: internal_constants_1.INTERNAL_MODULE_JWT_SECRET,
+                    useFactory: (config) => config.jwt_secret,
+                    inject: [internal_constants_1.INTERNAL_MODULE_OPTIONS],
+                },
+                ...(options.extraProviders || []),
+            ],
+        };
+    }
+    static forRoot(options) {
+        return Object.assign(Object.assign({}, this.register(options)), { global: true });
+    }
+    static forRootAsync(options) {
+        return Object.assign(Object.assign({}, this.registerAsync(options)), { global: true });
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: internal_constants_1.INTERNAL_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: internal_constants_1.INTERNAL_MODULE_OPTIONS,
+            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return optionsFactory.createInternalOptions(); }),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+InternalModule = InternalModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            services_1.CommentService,
+            services_1.ContentService,
+            services_1.SearchService,
+            { provide: internal_constants_1.AXIOS_INSTANCE_TOKEN, useValue: axios_1.default },
+        ],
+        exports: [services_1.CommentService, services_1.ContentService, services_1.SearchService],
+    })
+], InternalModule);
+exports.InternalModule = InternalModule;

package/dist/pipes/hid.pipe.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+export declare class InvalidHidException extends HttpException {
+    constructor(param: string);
+}
+export declare const Hid: (param: string) => ParameterDecorator;
+export declare const ApiHid: (param: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/pipes/hid.pipe.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiHid = exports.Hid = exports.InvalidHidException = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const itlab_functions_1 = require("itlab-functions");
+class ParseHidPipe {
+    constructor(param) {
+        this.param = param;
+    }
+    transform(value) {
+        const isString = typeof value === 'string' || value instanceof String;
+        if (isString && (0, itlab_functions_1.isID)(value.toString()))
+            return value.toString();
+        throw new InvalidHidException(this.param);
+    }
+}
+class InvalidHidException extends common_1.HttpException {
+    constructor(param) {
+        super(`Invalid parameter '${param}'`, common_1.HttpStatus.BAD_REQUEST);
+    }
+}
+exports.InvalidHidException = InvalidHidException;
+const Hid = (param) => (0, common_1.Param)(param, new ParseHidPipe(param));
+exports.Hid = Hid;
+const ApiHid = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({
+    name: param,
+    example: 'hallo-welt',
+    examples: {
+        'Hallo Welt': { value: 'hallo-welt' },
+        'Heute ist ein toller Tag': { value: 'heute-ist-ein-toller-tag' },
+    },
+}), (0, swagger_1.ApiBadRequestResponse)({ description: 'Invalid parameter' }));
+exports.ApiHid = ApiHid;

package/dist/pipes/id.pipe.d.ts

@@ -0,0 +1,6 @@
+import { HttpException } from '@nestjs/common';
+export declare class InvalidIdException extends HttpException {
+    constructor(param: string);
+}
+export declare const Id: (param: string) => ParameterDecorator;
+export declare const ApiId: (param: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/pipes/id.pipe.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiId = exports.Id = exports.InvalidIdException = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+class ParseIdPipe {
+    constructor(param) {
+        this.param = param;
+    }
+    transform(value) {
+        const isString = typeof value === 'string' || value instanceof String;
+        const isMongoId = /^(0x|0h)?[0-9A-F]+$/i.test(value) && value.length === 24;
+        if (isString && isMongoId)
+            return value.toString();
+        throw new InvalidIdException(this.param);
+    }
+}
+class InvalidIdException extends common_1.HttpException {
+    constructor(param) {
+        super(`Invalid parameter '${param}'`, common_1.HttpStatus.BAD_REQUEST);
+    }
+}
+exports.InvalidIdException = InvalidIdException;
+const Id = (param) => (0, common_1.Param)(param, new ParseIdPipe(param));
+exports.Id = Id;
+const ApiId = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({ name: param, example: ''.padEnd(24, '0') }), (0, swagger_1.ApiBadRequestResponse)({ description: 'Invalid parameter' }));
+exports.ApiId = ApiId;

package/dist/pipes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hid.pipe';
+export * from './id.pipe';
+export * from './target.pipe';

package/dist/pipes/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hid.pipe"), exports);
+__exportStar(require("./id.pipe"), exports);
+__exportStar(require("./target.pipe"), exports);

package/dist/pipes/target.pipe.d.ts

@@ -0,0 +1,16 @@
+import { HttpException } from '@nestjs/common';
+export declare enum Targets {
+    NEWSROOM = "news",
+    EVENTS = "event",
+    DEMOHIVE = "demo",
+    PODCASTS = "podcast",
+    SNIPPETS = "snippet",
+    BLIPS = "blip",
+    BOOKS = "book",
+    UNKNOWN = "unknown"
+}
+export declare class InvalidTargetException extends HttpException {
+    constructor(param: string);
+}
+export declare const Target: (param: string) => ParameterDecorator;
+export declare const ApiTarget: (param: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/pipes/target.pipe.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTarget = exports.Target = exports.InvalidTargetException = exports.Targets = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+var Targets;
+(function (Targets) {
+    Targets["NEWSROOM"] = "news";
+    Targets["EVENTS"] = "event";
+    Targets["DEMOHIVE"] = "demo";
+    Targets["PODCASTS"] = "podcast";
+    Targets["SNIPPETS"] = "snippet";
+    Targets["BLIPS"] = "blip";
+    Targets["BOOKS"] = "book";
+    Targets["UNKNOWN"] = "unknown";
+})(Targets = exports.Targets || (exports.Targets = {}));
+function generateExamples() {
+    const map = {};
+    Object.entries(Targets).forEach(([value, key]) => (map[key] = { value }));
+    return map;
+}
+class ParseTargetPipe {
+    constructor(param) {
+        this.param = param;
+    }
+    transform(value) {
+        if (Object.values(Targets).includes(value))
+            return value;
+        throw new InvalidTargetException(this.param);
+    }
+}
+class InvalidTargetException extends common_1.HttpException {
+    constructor(param) {
+        super(`Invalid parameter '${param}'`, common_1.HttpStatus.BAD_REQUEST);
+    }
+}
+exports.InvalidTargetException = InvalidTargetException;
+const Target = (param) => (0, common_1.Param)(param, new ParseTargetPipe(param));
+exports.Target = Target;
+const ApiTarget = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({
+    name: param,
+    example: Targets.NEWSROOM,
+    examples: generateExamples(),
+}), (0, swagger_1.ApiBadRequestResponse)({ description: 'Invalid parameter' }));
+exports.ApiTarget = ApiTarget;

package/dist/services/comment.service.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { Targets } from '../pipes/target.pipe';
+export declare type Comment = unknown;
+export declare class CommentService {
+    protected readonly instance: AxiosInstance;
+    protected readonly target: Targets;
+    protected readonly prefix: string;
+    constructor(instance?: AxiosInstance, target?: Targets, prefix?: string);
+    post(targetId: string, authorId: string, comment: Comment): Promise<Comment>;
+    delete(targetId: string): Promise<void>;
+}

package/dist/services/comment.service.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const internal_constants_1 = require("../internal.constants");
+const target_pipe_1 = require("../pipes/target.pipe");
+let CommentService = class CommentService {
+    constructor(instance = axios_1.default, target = target_pipe_1.Targets.UNKNOWN, prefix = 'comment/internal') {
+        this.instance = instance;
+        this.target = target;
+        this.prefix = prefix;
+    }
+    post(targetId, authorId, comment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.instance
+                    .post(`${this.prefix}/${this.target}/${targetId}/${authorId}`, comment)
+                    .then(({ data }) => resolve(data))
+                    .catch(({ response }) => reject(new common_1.HttpException(response.data, response.status)));
+            });
+        });
+    }
+    delete(targetId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.instance
+                    .delete(`${this.prefix}/${this.target}/${targetId}`)
+                    .then(() => resolve())
+                    .catch(({ response }) => reject(new common_1.HttpException(response.data, response.status)));
+            });
+        });
+    }
+};
+CommentService = __decorate([
+    __param(0, (0, common_1.Inject)(internal_constants_1.AXIOS_INSTANCE_TOKEN)),
+    __param(1, (0, common_1.Inject)(internal_constants_1.INTERNAL_MODULE_TARGET)),
+    __metadata("design:paramtypes", [Function, String, Object])
+], CommentService);
+exports.CommentService = CommentService;

package/dist/services/content.service.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from 'axios';
+import { Targets } from '../pipes/target.pipe';
+export declare type Content = unknown[];
+export declare class ContentService {
+    protected readonly instance: AxiosInstance;
+    protected readonly target: Targets;
+    protected readonly prefix: string;
+    constructor(instance?: AxiosInstance, target?: Targets, prefix?: string);
+    verify(contents: Content[]): Promise<void>;
+    post(targetId: string, contents: Content[]): Promise<void>;
+    delete(targetId: string): Promise<void>;
+}

package/dist/services/content.service.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const internal_constants_1 = require("../internal.constants");
+const target_pipe_1 = require("../pipes/target.pipe");
+let ContentService = class ContentService {
+    constructor(instance = axios_1.default, target = target_pipe_1.Targets.UNKNOWN, prefix = 'content/internal') {
+        this.instance = instance;
+        this.target = target;
+        this.prefix = prefix;
+    }
+    verify(contents) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.instance
+                    .post(`${this.prefix}/verify`, { contents })
+                    .then(() => resolve())
+                    .catch(({ response }) => reject(new common_1.HttpException(response.data, response.status)));
+            });
+        });
+    }
+    post(targetId, contents) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.instance
+                    .post(`${this.prefix}/${this.target}/${targetId}`, { contents })
+                    .then(() => resolve())
+                    .catch(({ response }) => reject(new common_1.HttpException(response.data, response.status)));
+            });
+        });
+    }
+    delete(targetId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.instance
+                    .delete(`${this.prefix}/${this.target}/${targetId}`)
+                    .then(() => resolve())
+                    .catch(({ response }) => reject(new common_1.HttpException(response.data, response.status)));
+            });
+        });
+    }
+};
+ContentService = __decorate([
+    __param(0, (0, common_1.Inject)(internal_constants_1.AXIOS_INSTANCE_TOKEN)),
+    __param(1, (0, common_1.Inject)(internal_constants_1.INTERNAL_MODULE_TARGET)),
+    __metadata("design:paramtypes", [Function, String, Object])
+], ContentService);
+exports.ContentService = ContentService;

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './comment.service';
+export * from './content.service';
+export * from './search.service';

package/dist/services/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./comment.service"), exports);
+__exportStar(require("./content.service"), exports);
+__exportStar(require("./search.service"), exports);

package/dist/services/search.service.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+import { Targets } from '../pipes/target.pipe';
+export declare class SearchService {
+    protected readonly instance: AxiosInstance;
+    protected readonly target: Targets;
+    protected readonly prefix: string;
+    constructor(instance?: AxiosInstance, target?: Targets, prefix?: string);
+}

package/dist/services/search.service.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const internal_constants_1 = require("../internal.constants");
+const target_pipe_1 = require("../pipes/target.pipe");
+let SearchService = class SearchService {
+    constructor(instance = axios_1.default, target = target_pipe_1.Targets.UNKNOWN, prefix = 'search/internal') {
+        this.instance = instance;
+        this.target = target;
+        this.prefix = prefix;
+    }
+};
+SearchService = __decorate([
+    __param(0, (0, common_1.Inject)(internal_constants_1.AXIOS_INSTANCE_TOKEN)),
+    __param(1, (0, common_1.Inject)(internal_constants_1.INTERNAL_MODULE_TARGET)),
+    __metadata("design:paramtypes", [Function, String, Object])
+], SearchService);
+exports.SearchService = SearchService;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "itlab-internal-services",
+  "author": {
+    "name": "Timo Scheuermann",
+    "email": "timo.scheuermann@sv-informatik.de",
+    "url": "https://timos.design"
+  },
+  "version": "0.0.1",
+  "type": "commonjs",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf -rf dist && tsc -p tsconfig.json",
+    "typecheck": "vue-tsc --noEmit",
+    "release:major": "npm version major && git push origin master --follow-tags",
+    "release:minor": "npm version minor && git push origin master --follow-tags",
+    "release:patch": "npm version patch && git push origin master --follow-tags",
+    "release": "npm run release:major",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "axios": "1.1.3",
+    "itlab-functions": "^0.0.2"
+  },
+  "devDependencies": {
+    "@nestjs/common": "9.2.0",
+    "@nestjs/core": "9.2.0",
+    "@nestjs/passport": "^9.0.0",
+    "@nestjs/platform-express": "9.2.0",
+    "@nestjs/swagger": "^6.1.3",
+    "@types/node": "18.11.9",
+    "@typescript-eslint/eslint-plugin": "5.42.1",
+    "@typescript-eslint/parser": "5.42.1",
+    "eslint": "8.27.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-import": "2.26.0",
+    "jest": "29.3.1",
+    "lint-staged": "13.0.3",
+    "passport-jwt": "^4.0.0",
+    "prettier": "2.7.1",
+    "reflect-metadata": "0.1.13",
+    "rimraf": "3.0.2",
+    "rxjs": "7.5.7",
+    "ts-jest": "29.0.3",
+    "typescript": "4.8.4"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^8.0.0 || ^9.0.0",
+    "@nestjs/core": "^8.0.0 || ^9.0.0",
+    "@nestjs/passport": "^8.0.0 || ^9.0.0",
+    "@nestjs/swagger": "^6.0.0",
+    "passport-jwt": "^4.0.0",
+    "reflect-metadata": "^0.1.12",
+    "rxjs": "^6.0.0 || ^7.0.0"
+  },
+  "lint-staged": {
+    "**/*.{ts,json}": []
+  }
+}