diff --git a/.history/api/src/app.module_20220722121129.ts b/.history/api/src/app.module_20220722121129.ts
new file mode 100644
index 000000000..cc06ec721
--- /dev/null
+++ b/.history/api/src/app.module_20220722121129.ts
@@ -0,0 +1,49 @@
+import { AppService } from './app.service';
+import { Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+import { JsTLService } from 'src/engines/jstl/jstl.service';
+import { TemplateService } from './core/template/template.service';
+import { AuditService } from './core/audit/audit.service';
+import { LambdaService } from './core/lambda/lambda.service';
+import { LambdaController } from './core/lambda/lambda.controller';
+import { TransformerService } from './core/transformer/transformer.service';
+import { TransformerController } from './core/transformer/transformer.controller';
+import { TemplateController } from './core/template/template.controller';
+import { JinjaService } from './engines/jinja/jinja.service';
+import { EjsService } from './engines/ejs/ejs.service';
+import { VMService } from './core/lambda/vm.service';
+import { SingletonServiceModule } from './singletonService.module';
+import { I18nController } from './core/i18n/i18n/i18n.controller';
+<<<<<<< HEAD
+=======
+import { SearchController } from './core/search/search.controller';
+>>>>>>> 3296e6186e13dc977ad9c926a00ee301aac12522
+
+@Module({
+  imports: [SingletonServiceModule],
+  controllers: [
+    LambdaController,
+    TransformerController,
+    TemplateController,
+    LambdaService,
+    I18nController,
+<<<<<<< HEAD
+=======
+    SearchController,
+>>>>>>> 3296e6186e13dc977ad9c926a00ee301aac12522
+  ],
+  exports: [VMService],
+  providers: [
+    AppService,
+    PrismaService,
+    JsTLService,
+    TemplateService,
+    AuditService,
+    LambdaService,
+    TransformerService,
+    JinjaService,
+    EjsService,
+    VMService,
+  ],
+})
+export class AppModule {}
diff --git a/.history/api/src/app.module_20220722121256.ts b/.history/api/src/app.module_20220722121256.ts
new file mode 100644
index 000000000..1d981051a
--- /dev/null
+++ b/.history/api/src/app.module_20220722121256.ts
@@ -0,0 +1,43 @@
+import { AppService } from './app.service';
+import { Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+import { JsTLService } from 'src/engines/jstl/jstl.service';
+import { TemplateService } from './core/template/template.service';
+import { AuditService } from './core/audit/audit.service';
+import { LambdaService } from './core/lambda/lambda.service';
+import { LambdaController } from './core/lambda/lambda.controller';
+import { TransformerService } from './core/transformer/transformer.service';
+import { TransformerController } from './core/transformer/transformer.controller';
+import { TemplateController } from './core/template/template.controller';
+import { JinjaService } from './engines/jinja/jinja.service';
+import { EjsService } from './engines/ejs/ejs.service';
+import { VMService } from './core/lambda/vm.service';
+import { SingletonServiceModule } from './singletonService.module';
+import { I18nController } from './core/i18n/i18n/i18n.controller';
+import { SearchController } from './core/search/search.controller';
+
+@Module({
+  imports: [SingletonServiceModule],
+  controllers: [
+    LambdaController,
+    TransformerController,
+    TemplateController,
+    LambdaService,
+    I18nController,
+    SearchController,
+  ],
+  exports: [VMService],
+  providers: [
+    AppService,
+    PrismaService,
+    JsTLService,
+    TemplateService,
+    AuditService,
+    LambdaService,
+    TransformerService,
+    JinjaService,
+    EjsService,
+    VMService,
+  ],
+})
+export class AppModule {}
diff --git a/.history/api/src/core/i18n/i18n/i18n.controller_20220722115508.ts b/.history/api/src/core/i18n/i18n/i18n.controller_20220722115508.ts
new file mode 100644
index 000000000..b35c26ecb
--- /dev/null
+++ b/.history/api/src/core/i18n/i18n/i18n.controller_20220722115508.ts
@@ -0,0 +1,163 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+} from '@nestjs/common';
+import { Template, TemplateType, Prisma } from '@prisma/client';
+import { PrismaService } from '../../../prisma.service';
+import { TransformerService } from '../../transformer/transformer.service';
+import { RenderDto, RenderDtoTest, RenderResponse } from '../../dto/render';
+import { JsTLService } from 'src/engines/jstl/jstl.service';
+import { TemplateService } from '../../template/template.service';
+import { JinjaService } from 'src/engines/jinja/jinja.service';
+import { EjsService } from 'src/engines/ejs/ejs.service';
+
+@Controller('i18n')
+export class I18nController {
+  constructor(
+    private readonly jinjaService: JinjaService,
+    private readonly ejsService: EjsService,
+    private readonly prisma: PrismaService,
+    private readonly transformerService: TransformerService,
+    private readonly templateService: TemplateService,
+    private readonly jstlService: JsTLService,
+  ) {}
+
+  @Post()
+  async addTemplate(
+    @Body() templateData: Prisma.TemplateCreateInput,
+  ): Promise<Template> {
+    const hasDuplicate = (arrayObj, colName) => {
+      var hash = Object.create(null);
+      return arrayObj.some((arr) => {
+        return (
+          arr[colName] && (hash[arr[colName]] || !(hash[arr[colName]] = true))
+        );
+      });
+    };
+    const isDuplicate: Boolean = hasDuplicate(
+      templateData.bodyI18n.createMany.data,
+      'lang',
+    );
+    if (isDuplicate) {
+      throw new BadRequestException('Unique language codes not allowed');
+    } else {
+      return this.templateService.createTemplate(templateData);
+    }
+  }
+
+  @Post('process')
+  async render(@Body() renderDto: RenderDto): Promise<RenderResponse> {
+    let processed;
+    let template;
+    if (renderDto.data.lang == null) {
+      processed = [];
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            select: {
+              body: true,
+              lang: true,
+            },
+          },
+        },
+      });
+      const bodyArr = template.bodyI18n;
+      if (bodyArr.length > 0) {
+        bodyArr.forEach(async (element) => {
+          let transformedData = renderDto.data;
+          for (const transformer of template.transformers) {
+            transformedData = await this.transformerService.process(
+              transformer.transformer,
+              transformedData,
+              transformer.path,
+            );
+          }
+          let proc;
+          switch (template.type) {
+            case TemplateType.JINJA:
+              proc = this.jinjaService.render(element.body, transformedData);
+
+            case TemplateType.JS_TEMPLATE_LITERALS:
+              proc = this.jstlService.render(element.body, transformedData);
+              break;
+
+            case TemplateType.EJS:
+              proc = this.ejsService.render(element.body, transformedData);
+              break;
+            default:
+              throw 'Templates without template types not allowed';
+          }
+          console.log({ lang: element.lang, processed: proc });
+          processed.push({ lang: element.lang, processed: proc });
+        });
+      } else {
+        processed = {
+          err: 'No template found for type ' + renderDto.data.type,
+        };
+      }
+    } else {
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            where: { lang: renderDto.data.lang },
+          },
+        },
+      });
+      let transformedData = renderDto.data;
+      for (const transformer of template.transformers) {
+        transformedData = await this.transformerService.process(
+          transformer.transformer,
+          transformedData,
+          transformer.path,
+        );
+      }
+      switch (template.type) {
+        case TemplateType.JINJA:
+          processed = this.jinjaService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+
+        case TemplateType.JS_TEMPLATE_LITERALS:
+          processed = this.jstlService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+
+        case TemplateType.EJS:
+          processed = this.ejsService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+        default:
+          throw 'Templates without template types not allowed';
+      }
+    }
+    return {
+      processed,
+      templateType: TemplateType.JS_TEMPLATE_LITERALS,
+      data: renderDto.data,
+      template: 'test',
+      meta: template.meta,
+    };
+  }
+}
diff --git a/.history/api/src/core/i18n/i18n/i18n.controller_20220722120831.ts b/.history/api/src/core/i18n/i18n/i18n.controller_20220722120831.ts
new file mode 100644
index 000000000..e70abc09d
--- /dev/null
+++ b/.history/api/src/core/i18n/i18n/i18n.controller_20220722120831.ts
@@ -0,0 +1,163 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+} from '@nestjs/common';
+import { Template, TemplateType, Prisma } from '@prisma/client';
+import { PrismaService } from '../../../prisma.service';
+import { TransformerService } from '../../transformer/transformer.service';
+import { RenderDto, RenderDtoTest, RenderResponse } from '../../dto/render';
+import { JsTLService } from 'src/engines/jstl/jstl.service';
+import { TemplateService } from '../../template/template.service';
+import { JinjaService } from 'src/engines/jinja/jinja.service';
+import { EjsService } from 'src/engines/ejs/ejs.service';
+
+@Controller('i18n')
+export class I18nController {
+  constructor(
+    private readonly jinjaService: JinjaService,
+    private readonly ejsService: EjsService,
+    private readonly prisma: PrismaService,
+    private readonly transformerService: TransformerService,
+    private readonly templateService: TemplateService,
+    private readonly jstlService: JsTLService,
+  ) {}
+
+  @Post()
+  async addTemplate(
+    @Body() templateData: Prisma.TemplateCreateInput,
+  ): Promise<Template> {
+    const hasDuplicate = (arrayObj, colName) => {
+      var hash = Object.create(null);
+      return arrayObj.some((arr) => {
+        return (
+          arr[colName] && (hash[arr[colName]] || !(hash[arr[colName]] = true))
+        );
+      });
+    };
+    const isDuplicate: Boolean = hasDuplicate(
+      templateData.bodyI18n.createMany.data,
+      'lang',
+    );
+    if (isDuplicate) {
+      throw new BadRequestException('Duplicate language codes not allowed');
+    } else {
+      return this.templateService.createTemplate(templateData);
+    }
+  }
+
+  @Post('process')
+  async render(@Body() renderDto: RenderDto): Promise<RenderResponse> {
+    let processed;
+    let template;
+    if (renderDto.data.lang == null) {
+      processed = [];
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            select: {
+              body: true,
+              lang: true,
+            },
+          },
+        },
+      });
+      const bodyArr = template.bodyI18n;
+      if (bodyArr.length > 0) {
+        bodyArr.forEach(async (element) => {
+          let transformedData = renderDto.data;
+          for (const transformer of template.transformers) {
+            transformedData = await this.transformerService.process(
+              transformer.transformer,
+              transformedData,
+              transformer.path,
+            );
+          }
+          let proc;
+          switch (template.type) {
+            case TemplateType.JINJA:
+              proc = this.jinjaService.render(element.body, transformedData);
+
+            case TemplateType.JS_TEMPLATE_LITERALS:
+              proc = this.jstlService.render(element.body, transformedData);
+              break;
+
+            case TemplateType.EJS:
+              proc = this.ejsService.render(element.body, transformedData);
+              break;
+            default:
+              throw 'Templates without template types not allowed';
+          }
+          console.log({ lang: element.lang, processed: proc });
+          processed.push({ lang: element.lang, processed: proc });
+        });
+      } else {
+        processed = {
+          err: 'No template found for type ' + renderDto.data.type,
+        };
+      }
+    } else {
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            where: { lang: renderDto.data.lang },
+          },
+        },
+      });
+      let transformedData = renderDto.data;
+      for (const transformer of template.transformers) {
+        transformedData = await this.transformerService.process(
+          transformer.transformer,
+          transformedData,
+          transformer.path,
+        );
+      }
+      switch (template.type) {
+        case TemplateType.JINJA:
+          processed = this.jinjaService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+
+        case TemplateType.JS_TEMPLATE_LITERALS:
+          processed = this.jstlService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+
+        case TemplateType.EJS:
+          processed = this.ejsService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+        default:
+          throw 'Templates without template types not allowed';
+      }
+    }
+    return {
+      processed,
+      templateType: TemplateType.JS_TEMPLATE_LITERALS,
+      data: renderDto.data,
+      template: 'test',
+      meta: template.meta,
+    };
+  }
+}
diff --git a/.history/api/src/core/i18n/i18n/i18n.controller_20220722121330.ts b/.history/api/src/core/i18n/i18n/i18n.controller_20220722121330.ts
new file mode 100644
index 000000000..ea78794c6
--- /dev/null
+++ b/.history/api/src/core/i18n/i18n/i18n.controller_20220722121330.ts
@@ -0,0 +1,139 @@
+import { Body, Controller, Post } from '@nestjs/common';
+import { Template, TemplateType, Prisma } from '@prisma/client';
+import { PrismaService } from '../../../prisma.service';
+import { TransformerService } from '../../transformer/transformer.service';
+import { RenderDto, RenderResponse } from '../../dto/render';
+import { JsTLService } from 'src/engines/jstl/jstl.service';
+import { TemplateService } from '../../template/template.service';
+import { JinjaService } from 'src/engines/jinja/jinja.service';
+import { EjsService } from 'src/engines/ejs/ejs.service';
+
+@Controller('i18n')
+export class I18nController {
+  constructor(
+    private readonly jinjaService: JinjaService,
+    private readonly ejsService: EjsService,
+    private readonly prisma: PrismaService,
+    private readonly transformerService: TransformerService,
+    private readonly templateService: TemplateService,
+    private readonly jstlService: JsTLService,
+  ) {}
+
+  @Post()
+  async addTemplate(
+    @Body() templateData: Prisma.TemplateCreateInput,
+  ): Promise<Template> {
+    return this.templateService.createTemplate(templateData);
+  }
+
+  @Post('process')
+  async render(@Body() renderDto: RenderDto): Promise<RenderResponse> {
+    let processed;
+    let template;
+    if (renderDto.data.lang == null) {
+      processed = [];
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            select: {
+              body: true,
+              lang: true,
+            },
+          },
+        },
+      });
+      const bodyArr = template.bodyI18n;
+      if (bodyArr.length > 0) {
+        bodyArr.forEach(async (element) => {
+          let transformedData = renderDto.data;
+          for (const transformer of template.transformers) {
+            transformedData = await this.transformerService.process(
+              transformer.transformer,
+              transformedData,
+              transformer.path,
+            );
+          }
+          let proc;
+          switch (template.type) {
+            case TemplateType.JINJA:
+              proc = this.jinjaService.render(element.body, transformedData);
+
+            case TemplateType.JS_TEMPLATE_LITERALS:
+              proc = this.jstlService.render(element.body, transformedData);
+              break;
+
+            case TemplateType.EJS:
+              proc = this.ejsService.render(element.body, transformedData);
+              break;
+            default:
+              throw 'Templates without template types not allowed';
+          }
+          console.log({ lang: element.lang, processed: proc });
+          processed.push({ lang: element.lang, processed: proc });
+        });
+      } else {
+        processed = {
+          err: 'No template found for type ' + renderDto.data.type,
+        };
+      }
+    } else {
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            where: { lang: renderDto.data.lang },
+          },
+        },
+      });
+      let transformedData = renderDto.data;
+      for (const transformer of template.transformers) {
+        transformedData = await this.transformerService.process(
+          transformer.transformer,
+          transformedData,
+          transformer.path,
+        );
+      }
+      switch (template.type) {
+        case TemplateType.JINJA:
+          processed = this.jinjaService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+
+        case TemplateType.JS_TEMPLATE_LITERALS:
+          processed = this.jstlService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+
+        case TemplateType.EJS:
+          processed = this.ejsService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+        default:
+          throw 'Templates without template types not allowed';
+      }
+    }
+    return {
+      processed,
+      templateType: TemplateType.JS_TEMPLATE_LITERALS,
+      data: renderDto.data,
+      template: 'test',
+      meta: template.meta,
+    };
+  }
+}
diff --git a/.history/api/src/core/i18n/i18n/i18n.controller_20220722121600.ts b/.history/api/src/core/i18n/i18n/i18n.controller_20220722121600.ts
new file mode 100644
index 000000000..6dbe2ebcf
--- /dev/null
+++ b/.history/api/src/core/i18n/i18n/i18n.controller_20220722121600.ts
@@ -0,0 +1,163 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+} from '@nestjs/common';
+import { Template, TemplateType, Prisma } from '@prisma/client';
+import { PrismaService } from '../../../prisma.service';
+import { TransformerService } from '../../transformer/transformer.service';
+import { RenderDto, RenderResponse } from '../../dto/render';
+import { JsTLService } from 'src/engines/jstl/jstl.service';
+import { TemplateService } from '../../template/template.service';
+import { JinjaService } from 'src/engines/jinja/jinja.service';
+import { EjsService } from 'src/engines/ejs/ejs.service';
+
+@Controller('i18n')
+export class I18nController {
+  constructor(
+    private readonly jinjaService: JinjaService,
+    private readonly ejsService: EjsService,
+    private readonly prisma: PrismaService,
+    private readonly transformerService: TransformerService,
+    private readonly templateService: TemplateService,
+    private readonly jstlService: JsTLService,
+  ) {}
+
+  @Post()
+  async addTemplate(
+    @Body() templateData: Prisma.TemplateCreateInput,
+  ): Promise<Template> {
+    const hasDuplicate = (arrayObj, colName) => {
+      var hash = Object.create(null);
+      return arrayObj.some((arr) => {
+        return (
+          arr[colName] && (hash[arr[colName]] || !(hash[arr[colName]] = true))
+        );
+      });
+    };
+    const isDuplicate: Boolean = hasDuplicate(
+      templateData.bodyI18n.createMany.data,
+      'lang',
+    );
+    if (isDuplicate) {
+      throw new BadRequestException('Duplicate language codes not allowed');
+    } else {
+      return this.templateService.createTemplate(templateData);
+    }
+  }
+
+  @Post('process')
+  async render(@Body() renderDto: RenderDto): Promise<RenderResponse> {
+    let processed;
+    let template;
+    if (renderDto.data.lang == null) {
+      processed = [];
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            select: {
+              body: true,
+              lang: true,
+            },
+          },
+        },
+      });
+      const bodyArr = template.bodyI18n;
+      if (bodyArr.length > 0) {
+        bodyArr.forEach(async (element) => {
+          let transformedData = renderDto.data;
+          for (const transformer of template.transformers) {
+            transformedData = await this.transformerService.process(
+              transformer.transformer,
+              transformedData,
+              transformer.path,
+            );
+          }
+          let proc;
+          switch (template.type) {
+            case TemplateType.JINJA:
+              proc = this.jinjaService.render(element.body, transformedData);
+
+            case TemplateType.JS_TEMPLATE_LITERALS:
+              proc = this.jstlService.render(element.body, transformedData);
+              break;
+
+            case TemplateType.EJS:
+              proc = this.ejsService.render(element.body, transformedData);
+              break;
+            default:
+              throw 'Templates without template types not allowed';
+          }
+          console.log({ lang: element.lang, processed: proc });
+          processed.push({ lang: element.lang, processed: proc });
+        });
+      } else {
+        processed = {
+          err: 'No template found for type ' + renderDto.data.type,
+        };
+      }
+    } else {
+      template = await this.prisma.template.findUnique({
+        where: { id: renderDto.id },
+        include: {
+          transformers: {
+            include: {
+              transformer: true,
+            },
+          },
+          bodyI18n: {
+            where: { lang: renderDto.data.lang },
+          },
+        },
+      });
+      let transformedData = renderDto.data;
+      for (const transformer of template.transformers) {
+        transformedData = await this.transformerService.process(
+          transformer.transformer,
+          transformedData,
+          transformer.path,
+        );
+      }
+      switch (template.type) {
+        case TemplateType.JINJA:
+          processed = this.jinjaService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+
+        case TemplateType.JS_TEMPLATE_LITERALS:
+          processed = this.jstlService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+
+        case TemplateType.EJS:
+          processed = this.ejsService.render(
+            template.bodyI18n[0].body,
+            transformedData,
+          );
+          break;
+        default:
+          throw 'Templates without template types not allowed';
+      }
+    }
+    return {
+      processed,
+      templateType: TemplateType.JS_TEMPLATE_LITERALS,
+      data: renderDto.data,
+      template: 'test',
+      meta: template.meta,
+    };
+  }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722121129.ts b/.history/api/src/core/search/search.controller_20220722121129.ts
new file mode 100644
index 000000000..cf0747ea6
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722121129.ts
@@ -0,0 +1,21 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+    constructor(
+        private readonly templateService: TemplateService,
+    ){}
+
+    @Get('tag')
+    async searchTag(@Query() queryString: string): Promise<Template[]>{
+        return this.templateService.searchTag(queryString);
+    }
+
+    @Get('body')
+    async searchTemplateBody(@Query() queryString: string): Promise<Template[]>{
+        return this.templateService.searchBody(queryString);
+    }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722122005.ts b/.history/api/src/core/search/search.controller_20220722122005.ts
new file mode 100644
index 000000000..1f537b877
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722122005.ts
@@ -0,0 +1,20 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get('tag')
+  async searchTag(@Query() queryString: string): Promise<Template[]> {
+    return this.templateService.searchTag(queryString);
+  }
+
+  @Get('body')
+  async searchTemplateBody(@Query() queryString: string): Promise<Template[]> {
+    console.log(queryString);
+    return this.templateService.searchBody(queryString);
+  }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722122103.ts b/.history/api/src/core/search/search.controller_20220722122103.ts
new file mode 100644
index 000000000..db1b7a92c
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722122103.ts
@@ -0,0 +1,20 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get('tag')
+  async searchTag(@Query() queryString: string): Promise<Template[]> {
+    return this.templateService.searchTag(queryString);
+  }
+
+  @Get('body')
+  async searchTemplateBody(@Query() queryString: string): Promise<Template[]> {
+    console.log({ queryString });
+    return this.templateService.searchBody(queryString);
+  }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722122109.ts b/.history/api/src/core/search/search.controller_20220722122109.ts
new file mode 100644
index 000000000..db1b7a92c
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722122109.ts
@@ -0,0 +1,20 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get('tag')
+  async searchTag(@Query() queryString: string): Promise<Template[]> {
+    return this.templateService.searchTag(queryString);
+  }
+
+  @Get('body')
+  async searchTemplateBody(@Query() queryString: string): Promise<Template[]> {
+    console.log({ queryString });
+    return this.templateService.searchBody(queryString);
+  }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722122515.ts b/.history/api/src/core/search/search.controller_20220722122515.ts
new file mode 100644
index 000000000..fe00abf3b
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722122515.ts
@@ -0,0 +1,20 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get('tag')
+  async searchTag(@Query() queryString: string): Promise<Template[]> {
+    return this.templateService.searchTag(queryString);
+  }
+
+  @Get('body')
+  async searchTemplateBody(@Query() queryString: {queryString: string}): Promise<Template[]> {
+    console.log({ queryString.queryString });
+    return this.templateService.searchBody(queryString.queryString);
+  }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722122604.ts b/.history/api/src/core/search/search.controller_20220722122604.ts
new file mode 100644
index 000000000..3667c67fc
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722122604.ts
@@ -0,0 +1,22 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get('tag')
+  async searchTag(@Query() queryString: string): Promise<Template[]> {
+    return this.templateService.searchTag(queryString);
+  }
+
+  @Get('body')
+  async searchTemplateBody(
+    @Query() queryString: { queryString: string },
+  ): Promise<Template[]> {
+    console.log({ test: queryString.queryString });
+    return this.templateService.searchBody(queryString.queryString);
+  }
+}
diff --git a/.history/api/src/core/search/search.controller_20220722122916.ts b/.history/api/src/core/search/search.controller_20220722122916.ts
new file mode 100644
index 000000000..137e9bd5e
--- /dev/null
+++ b/.history/api/src/core/search/search.controller_20220722122916.ts
@@ -0,0 +1,24 @@
+/* eslint-disable prettier/prettier */
+import { Controller, Get, Query } from '@nestjs/common';
+import { Template } from '@prisma/client';
+import { TemplateService } from '../template/template.service';
+
+@Controller('search')
+export class SearchController {
+  constructor(private readonly templateService: TemplateService) {}
+
+  @Get('tag')
+  async searchTag(
+    @Query() queryString: { queryString: string },
+  ): Promise<Template[]> {
+    return this.templateService.searchTag(queryString.queryString);
+  }
+
+  @Get('body')
+  async searchTemplateBody(
+    @Query() queryString: { queryString: string },
+  ): Promise<Template[]> {
+    console.log({ test: queryString.queryString });
+    return this.templateService.searchBody(queryString.queryString);
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722121129.ts b/.history/api/src/core/template/template.service_20220722121129.ts
new file mode 100644
index 000000000..92878a5ff
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722121129.ts
@@ -0,0 +1,96 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722123220.ts b/.history/api/src/core/template/template.service_20220722123220.ts
new file mode 100644
index 000000000..be153814b
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722123220.ts
@@ -0,0 +1,97 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722123647.ts b/.history/api/src/core/template/template.service_20220722123647.ts
new file mode 100644
index 000000000..2438cb94e
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722123647.ts
@@ -0,0 +1,102 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    try {
+      return this.prisma.template.findMany({
+        take: 200,
+        where: {
+          tag: {
+            has: queryString,
+          },
+        },
+      });
+    } catch (err) {
+      console.log(err);
+      return [];
+    }
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722123813.ts b/.history/api/src/core/template/template.service_20220722123813.ts
new file mode 100644
index 000000000..c4d5587cc
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722123813.ts
@@ -0,0 +1,104 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    try {
+      console.log('Search Initialized');
+      return this.prisma.template.findMany({
+        take: 200,
+        where: {
+          tag: {
+            has: queryString,
+          },
+        },
+      });
+    } catch (err) {
+      console.log('ERR');
+      console.log(err);
+      return [];
+    }
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722124551.ts b/.history/api/src/core/template/template.service_20220722124551.ts
new file mode 100644
index 000000000..6183dde4f
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722124551.ts
@@ -0,0 +1,100 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      include: {
+        bodyI18n: true,
+      },
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722125013.ts b/.history/api/src/core/template/template.service_20220722125013.ts
new file mode 100644
index 000000000..9097fc65d
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722125013.ts
@@ -0,0 +1,111 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    console.log({
+      body: {
+        contains: queryString,
+        mode: 'insensitive',
+      },
+      bodyI18n: {
+        every: {
+          body: {
+            contains: queryString,
+            mode: 'insensitive',
+          },
+        },
+      },
+    });
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722125242.ts b/.history/api/src/core/template/template.service_20220722125242.ts
new file mode 100644
index 000000000..b728a2c0a
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722125242.ts
@@ -0,0 +1,114 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    console.log({
+      body: {
+        contains: queryString,
+        mode: 'insensitive',
+      },
+      bodyI18n: {
+        every: {
+          body: {
+            contains: queryString,
+            mode: 'insensitive',
+          },
+        },
+      },
+    });
+    return this.prisma.template.findMany({
+      take: 200,
+      include: {
+        bodyI18n: true,
+      },
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722125417.ts b/.history/api/src/core/template/template.service_20220722125417.ts
new file mode 100644
index 000000000..b706f9515
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722125417.ts
@@ -0,0 +1,114 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    console.log({
+      body: {
+        contains: queryString,
+        mode: 'insensitive',
+      },
+      bodyI18n: {
+        every: {
+          body: {
+            contains: queryString,
+            mode: 'insensitive',
+          },
+        },
+      },
+    });
+    return this.prisma.template.findMany({
+      take: 200,
+      include: {
+        bodyI18n: true,
+      },
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              some: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722125504.ts b/.history/api/src/core/template/template.service_20220722125504.ts
new file mode 100644
index 000000000..b728a2c0a
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722125504.ts
@@ -0,0 +1,114 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    console.log({
+      body: {
+        contains: queryString,
+        mode: 'insensitive',
+      },
+      bodyI18n: {
+        every: {
+          body: {
+            contains: queryString,
+            mode: 'insensitive',
+          },
+        },
+      },
+    });
+    return this.prisma.template.findMany({
+      take: 200,
+      include: {
+        bodyI18n: true,
+      },
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+            bodyI18n: {
+              every: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722130046.ts b/.history/api/src/core/template/template.service_20220722130046.ts
new file mode 100644
index 000000000..b50277a68
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722130046.ts
@@ -0,0 +1,106 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    console.log({
+      body: {
+        contains: queryString,
+        mode: 'insensitive',
+      },
+      bodyI18n: {
+        every: {
+          body: {
+            contains: queryString,
+            mode: 'insensitive',
+          },
+        },
+      },
+    });
+    return this.prisma.template.findMany({
+      take: 200,
+      include: {
+        bodyI18n: true,
+      },
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/.history/api/src/core/template/template.service_20220722130148.ts b/.history/api/src/core/template/template.service_20220722130148.ts
new file mode 100644
index 000000000..761e36231
--- /dev/null
+++ b/.history/api/src/core/template/template.service_20220722130148.ts
@@ -0,0 +1,116 @@
+import { Injectable } from '@nestjs/common';
+import { Template, Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma.service';
+
+@Injectable()
+export class TemplateService {
+  constructor(private prisma: PrismaService) {}
+
+  async template(
+    userWhereUniqueInput: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template | null> {
+    return this.prisma.template.findUnique({
+      where: userWhereUniqueInput,
+      include: {
+        transformers: true,
+        bodyI18n: true,
+      },
+    });
+  }
+
+  async templates(params: {
+    skip?: number;
+    take?: number;
+    cursor?: Prisma.TemplateWhereUniqueInput;
+    where?: Prisma.TemplateWhereInput;
+    orderBy?: Prisma.TemplateOrderByWithRelationInput;
+  }): Promise<Template[]> {
+    const { skip, take, cursor, where, orderBy } = params;
+    return this.prisma.template.findMany({
+      skip,
+      take,
+      cursor,
+      where,
+      orderBy,
+    });
+  }
+
+  async createTemplate(data: Prisma.TemplateCreateInput): Promise<Template> {
+    return this.prisma.template.create({
+      data,
+    });
+  }
+
+  async updateTemplate(params: {
+    where: Prisma.TemplateWhereUniqueInput;
+    data: Prisma.TemplateUpdateInput;
+  }): Promise<Template> {
+    const { where, data } = params;
+    return this.prisma.template.update({
+      data,
+      where,
+    });
+  }
+
+  async deleteTemplate(
+    where: Prisma.TemplateWhereUniqueInput,
+  ): Promise<Template> {
+    return this.prisma.template.delete({
+      where,
+    });
+  }
+
+  async searchTag(queryString: string): Promise<Template[]> {
+    return this.prisma.template.findMany({
+      take: 200,
+      where: {
+        tag: {
+          has: queryString,
+        },
+      },
+    });
+  }
+
+  async searchBody(queryString: string): Promise<Template[]> {
+    console.log({
+      body: {
+        contains: queryString,
+        mode: 'insensitive',
+      },
+      bodyI18n: {
+        every: {
+          body: {
+            contains: queryString,
+            mode: 'insensitive',
+          },
+        },
+      },
+    });
+    return this.prisma.template.findMany({
+      take: 200,
+      include: {
+        bodyI18n: true,
+      },
+      where: {
+        OR: [
+          {
+            body: {
+              contains: queryString,
+              mode: 'insensitive',
+            },
+          },
+          {
+            bodyI18n: {
+              some: {
+                body: {
+                  contains: queryString,
+                  mode: 'insensitive',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+  }
+}
diff --git a/api/prisma/migrations/20211129180148_/migration.sql b/api/prisma/migrations/20211129180148_/migration.sql
deleted file mode 100644
index 7943d2a08..000000000
--- a/api/prisma/migrations/20211129180148_/migration.sql
+++ /dev/null
@@ -1,35 +0,0 @@
--- CreateEnum
-CREATE TYPE "TemplateType" AS ENUM ('JINJA', 'JS_TEMPLATE_LITERALS');
-
--- CreateEnum
-CREATE TYPE "Event" AS ENUM ('RENDERED');
-
--- CreateTable
-CREATE TABLE "Template" (
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "id" BIGSERIAL NOT NULL,
-    "type" "TemplateType" NOT NULL,
-    "useCase" TEXT NOT NULL,
-    "body" TEXT NOT NULL,
-    "meta" JSONB NOT NULL,
-    "user" UUID NOT NULL,
-    "tag" TEXT[],
-
-    CONSTRAINT "Template_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Audit" (
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "id" BIGSERIAL NOT NULL,
-    "templateId" BIGINT NOT NULL,
-    "event" "Event" NOT NULL,
-    "renderedText" TEXT NOT NULL,
-
-    CONSTRAINT "Audit_pkey" PRIMARY KEY ("id")
-);
-
--- AddForeignKey
-ALTER TABLE "Audit" ADD CONSTRAINT "Audit_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/api/prisma/migrations/20211130061342_/migration.sql b/api/prisma/migrations/20211130061342_/migration.sql
deleted file mode 100644
index a5763383e..000000000
--- a/api/prisma/migrations/20211130061342_/migration.sql
+++ /dev/null
@@ -1,14 +0,0 @@
--- AlterEnum
--- This migration adds more than one value to an enum.
--- With PostgreSQL versions 11 and earlier, this is not possible
--- in a single migration. This can be worked around by creating
--- multiple migrations, each migration adding only one value to
--- the enum.
-
-
-ALTER TYPE "Event" ADD VALUE 'ADDED';
-ALTER TYPE "Event" ADD VALUE 'DELETED';
-ALTER TYPE "Event" ADD VALUE 'MODIFIED';
-
--- AlterTable
-ALTER TABLE "Audit" ADD COLUMN     "meta" JSONB;
diff --git a/api/prisma/migrations/20211130061634_/migration.sql b/api/prisma/migrations/20211130061634_/migration.sql
deleted file mode 100644
index 66b623823..000000000
--- a/api/prisma/migrations/20211130061634_/migration.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- AlterTable
-ALTER TABLE "Template" ALTER COLUMN "meta" DROP NOT NULL;
diff --git a/api/prisma/migrations/20220212044256_lambda/migration.sql b/api/prisma/migrations/20220212044256_lambda/migration.sql
deleted file mode 100644
index 839ab30a5..000000000
--- a/api/prisma/migrations/20220212044256_lambda/migration.sql
+++ /dev/null
@@ -1,69 +0,0 @@
--- CreateEnum
-CREATE TYPE "TransformerType" AS ENUM ('OPTIONS', 'FUNCTION_EXTERNAL', 'FUNCTION_INTERNAL');
-
--- CreateEnum
-CREATE TYPE "Language" AS ENUM ('JAVASCRIPT', 'TYPESCRIPT');
-
--- CreateEnum
-CREATE TYPE "FunctionExecutionEvent" AS ENUM ('ADDED', 'DELETED', 'MODIFIED', 'RUN');
-
--- CreateTable
-CREATE TABLE "Transformer" (
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "id" BIGSERIAL NOT NULL,
-    "type" "TransformerType" NOT NULL,
-    "meta" JSONB,
-    "sampleData" JSONB,
-    "functionDID" TEXT NOT NULL,
-
-    CONSTRAINT "Transformer_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ExternalLambda" (
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "id" BIGSERIAL NOT NULL,
-    "uri" TEXT NOT NULL,
-    "meta" JSONB,
-    "sampleData" JSONB,
-
-    CONSTRAINT "ExternalLambda_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Lambda" (
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "id" BIGSERIAL NOT NULL,
-    "tags" TEXT[],
-    "name" TEXT NOT NULL,
-    "body" TEXT NOT NULL,
-    "user" UUID NOT NULL,
-    "isOpen" BOOLEAN NOT NULL,
-    "isActive" BOOLEAN NOT NULL,
-    "isPublic" BOOLEAN NOT NULL,
-    "language" "Language" NOT NULL,
-
-    CONSTRAINT "Lambda_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ExecutionAudit" (
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "id" BIGSERIAL NOT NULL,
-    "event" "FunctionExecutionEvent" NOT NULL,
-    "meta" JSONB,
-    "transformerId" BIGINT NOT NULL,
-    "templateId" BIGINT NOT NULL,
-
-    CONSTRAINT "ExecutionAudit_pkey" PRIMARY KEY ("id")
-);
-
--- AddForeignKey
-ALTER TABLE "ExecutionAudit" ADD CONSTRAINT "ExecutionAudit_transformerId_fkey" FOREIGN KEY ("transformerId") REFERENCES "Transformer"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "ExecutionAudit" ADD CONSTRAINT "ExecutionAudit_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/api/prisma/migrations/20220215043840_transformer_function_did_optional/migration.sql b/api/prisma/migrations/20220215043840_transformer_function_did_optional/migration.sql
deleted file mode 100644
index 09d69554e..000000000
--- a/api/prisma/migrations/20220215043840_transformer_function_did_optional/migration.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- AlterTable
-ALTER TABLE "Transformer" ALTER COLUMN "functionDID" DROP NOT NULL;
diff --git a/api/prisma/migrations/20220215061140_add_transformer_path_mapping/migration.sql b/api/prisma/migrations/20220215061140_add_transformer_path_mapping/migration.sql
deleted file mode 100644
index 372937250..000000000
--- a/api/prisma/migrations/20220215061140_add_transformer_path_mapping/migration.sql
+++ /dev/null
@@ -1,12 +0,0 @@
--- CreateTable
-CREATE TABLE "TransformerPathMapping" (
-    "id" BIGSERIAL NOT NULL,
-    "path" TEXT NOT NULL,
-    "transformer" "TransformerType" NOT NULL,
-    "templateId" BIGINT,
-
-    CONSTRAINT "TransformerPathMapping_pkey" PRIMARY KEY ("id")
-);
-
--- AddForeignKey
-ALTER TABLE "TransformerPathMapping" ADD CONSTRAINT "TransformerPathMapping_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE SET NULL ON UPDATE CASCADE;
diff --git a/api/prisma/migrations/20220215061308_make_usecase_optional/migration.sql b/api/prisma/migrations/20220215061308_make_usecase_optional/migration.sql
deleted file mode 100644
index be2cf5988..000000000
--- a/api/prisma/migrations/20220215061308_make_usecase_optional/migration.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- AlterTable
-ALTER TABLE "Template" ALTER COLUMN "useCase" DROP NOT NULL;
diff --git a/api/prisma/migrations/20220215061448_fix_transformer_path_mapping/migration.sql b/api/prisma/migrations/20220215061448_fix_transformer_path_mapping/migration.sql
deleted file mode 100644
index 7ba3f9169..000000000
--- a/api/prisma/migrations/20220215061448_fix_transformer_path_mapping/migration.sql
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
-  Warnings:
-
-  - You are about to drop the column `transformer` on the `TransformerPathMapping` table. All the data in the column will be lost.
-  - Added the required column `transformerId` to the `TransformerPathMapping` table without a default value. This is not possible if the table is not empty.
-
-*/
--- AlterTable
-ALTER TABLE "TransformerPathMapping" DROP COLUMN "transformer",
-ADD COLUMN     "transformerId" BIGINT NOT NULL;
-
--- AddForeignKey
-ALTER TABLE "TransformerPathMapping" ADD CONSTRAINT "TransformerPathMapping_transformerId_fkey" FOREIGN KEY ("transformerId") REFERENCES "Transformer"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/api/prisma/migrations/20220215121110_add_ejs/migration.sql b/api/prisma/migrations/20220215121110_add_ejs/migration.sql
deleted file mode 100644
index b48a05c1b..000000000
--- a/api/prisma/migrations/20220215121110_add_ejs/migration.sql
+++ /dev/null
@@ -1,2 +0,0 @@
--- AlterEnum
-ALTER TYPE "TemplateType" ADD VALUE 'EJS';
diff --git a/api/prisma/migrations/20220709073700_dummy/migration.sql b/api/prisma/migrations/20220709073700_dummy/migration.sql
deleted file mode 100644
index f025d3152..000000000
--- a/api/prisma/migrations/20220709073700_dummy/migration.sql
+++ /dev/null
@@ -1,18 +0,0 @@
--- AlterTable
-ALTER TABLE "Template" ALTER COLUMN "body" DROP NOT NULL;
-
--- CreateTable
-CREATE TABLE "BodyI18n" (
-    "id" BIGSERIAL NOT NULL,
-    "lang" TEXT NOT NULL,
-    "body" TEXT NOT NULL,
-    "templateId" BIGINT NOT NULL,
-
-    CONSTRAINT "BodyI18n_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "BodyI18n_lang_unique_constraint" ON "BodyI18n"("lang");
-
--- AddForeignKey
-ALTER TABLE "BodyI18n" ADD CONSTRAINT "BodyI18n_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/api/prisma/migrations/20220722062227_/migration.sql b/api/prisma/migrations/20220722062227_/migration.sql
new file mode 100644
index 000000000..a7a820608
--- /dev/null
+++ b/api/prisma/migrations/20220722062227_/migration.sql
@@ -0,0 +1,138 @@
+-- CreateEnum
+CREATE TYPE "TemplateType" AS ENUM ('JINJA', 'JS_TEMPLATE_LITERALS', 'EJS');
+
+-- CreateEnum
+CREATE TYPE "TransformerType" AS ENUM ('OPTIONS', 'FUNCTION_EXTERNAL', 'FUNCTION_INTERNAL');
+
+-- CreateEnum
+CREATE TYPE "Language" AS ENUM ('JAVASCRIPT', 'TYPESCRIPT');
+
+-- CreateEnum
+CREATE TYPE "Event" AS ENUM ('ADDED', 'DELETED', 'MODIFIED', 'RENDERED');
+
+-- CreateEnum
+CREATE TYPE "FunctionExecutionEvent" AS ENUM ('ADDED', 'DELETED', 'MODIFIED', 'RUN');
+
+-- CreateEnum
+CREATE TYPE "LanguageCodes" AS ENUM ('aa', 'ab', 'af', 'ak', 'am', 'ar', 'an', 'as', 'av', 'ae', 'ay', 'az', 'ba', 'bm', 'be', 'bn', 'bi', 'bo', 'bs', 'br', 'bg', 'ca', 'cs', 'ch', 'ce', 'cu', 'cv', 'kw', 'co', 'cr', 'cy', 'da', 'de', 'dv', 'dz', 'el', 'en', 'eo', 'et', 'eu', 'ee', 'fo', 'fa', 'fj', 'fi', 'fr', 'fy', 'ff', 'gd', 'ga', 'gl', 'gv', 'gn', 'gu', 'ht', 'ha', 'sh', 'he', 'hz', 'hi', 'ho', 'hr', 'hu', 'hy', 'ig', 'io', 'ii', 'iu', 'ie', 'ia', 'id', 'ik', 'is', 'it', 'jv', 'ja', 'kl', 'kn', 'ks', 'ka', 'kr', 'kk', 'km', 'ki', 'rw', 'ky', 'kv', 'kg', 'ko', 'kj', 'ku', 'lo', 'la', 'lv', 'li', 'ln', 'lt', 'lb', 'lu', 'lg', 'mh', 'ml', 'mr', 'mk', 'mg', 'mt', 'mn', 'mi', 'ms', 'my', 'na', 'nv', 'nr', 'nd', 'ng', 'ne', 'nl', 'nn', 'nb', 'no', 'ny', 'oc', 'oj', 'or', 'om', 'os', 'pa', 'pi', 'pl', 'pt', 'ps', 'qu', 'rm', 'ro', 'rn', 'ru', 'sg', 'sa', 'si', 'sk', 'sl', 'se', 'sm', 'sn', 'sd', 'so', 'st', 'es', 'sq', 'sc', 'sr', 'ss', 'su', 'sw', 'sv', 'ty', 'ta', 'tt', 'te', 'tg', 'tl', 'th', 'ti', 'to', 'tn', 'ts', 'tk', 'tr', 'tw', 'ug', 'uk', 'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi', 'yo', 'za', 'zh', 'zu');
+
+-- CreateTable
+CREATE TABLE "TransformerPathMapping" (
+    "id" BIGSERIAL NOT NULL,
+    "path" TEXT NOT NULL,
+    "templateId" BIGINT,
+    "transformerId" BIGINT NOT NULL,
+
+    CONSTRAINT "TransformerPathMapping_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Template" (
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "id" BIGSERIAL NOT NULL,
+    "type" "TemplateType" NOT NULL,
+    "useCase" TEXT,
+    "body" TEXT,
+    "meta" JSONB,
+    "user" UUID NOT NULL,
+    "tag" TEXT[],
+
+    CONSTRAINT "Template_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Audit" (
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "id" BIGSERIAL NOT NULL,
+    "templateId" BIGINT NOT NULL,
+    "event" "Event" NOT NULL,
+    "renderedText" TEXT NOT NULL,
+    "meta" JSONB,
+
+    CONSTRAINT "Audit_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Transformer" (
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "id" BIGSERIAL NOT NULL,
+    "type" "TransformerType" NOT NULL,
+    "meta" JSONB,
+    "sampleData" JSONB,
+    "functionDID" TEXT,
+
+    CONSTRAINT "Transformer_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "ExternalLambda" (
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "id" BIGSERIAL NOT NULL,
+    "uri" TEXT NOT NULL,
+    "meta" JSONB,
+    "sampleData" JSONB,
+
+    CONSTRAINT "ExternalLambda_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Lambda" (
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "id" BIGSERIAL NOT NULL,
+    "tags" TEXT[],
+    "name" TEXT NOT NULL,
+    "body" TEXT NOT NULL,
+    "user" UUID NOT NULL,
+    "isOpen" BOOLEAN NOT NULL,
+    "isActive" BOOLEAN NOT NULL,
+    "isPublic" BOOLEAN NOT NULL,
+    "language" "Language" NOT NULL,
+
+    CONSTRAINT "Lambda_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "ExecutionAudit" (
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "id" BIGSERIAL NOT NULL,
+    "event" "FunctionExecutionEvent" NOT NULL,
+    "meta" JSONB,
+    "transformerId" BIGINT NOT NULL,
+    "templateId" BIGINT NOT NULL,
+
+    CONSTRAINT "ExecutionAudit_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "BodyI18n" (
+    "id" BIGSERIAL NOT NULL,
+    "lang" "LanguageCodes" NOT NULL,
+    "body" TEXT NOT NULL,
+    "templateId" BIGINT NOT NULL,
+
+    CONSTRAINT "BodyI18n_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "TransformerPathMapping" ADD CONSTRAINT "TransformerPathMapping_transformerId_fkey" FOREIGN KEY ("transformerId") REFERENCES "Transformer"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TransformerPathMapping" ADD CONSTRAINT "TransformerPathMapping_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Audit" ADD CONSTRAINT "Audit_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ExecutionAudit" ADD CONSTRAINT "ExecutionAudit_transformerId_fkey" FOREIGN KEY ("transformerId") REFERENCES "Transformer"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ExecutionAudit" ADD CONSTRAINT "ExecutionAudit_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "BodyI18n" ADD CONSTRAINT "BodyI18n_templateId_fkey" FOREIGN KEY ("templateId") REFERENCES "Template"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
diff --git a/api/prisma/schema.prisma b/api/prisma/schema.prisma
index 79c178afd..6fb3969b6 100644
--- a/api/prisma/schema.prisma
+++ b/api/prisma/schema.prisma
@@ -318,7 +318,7 @@ model ExecutionAudit {
 
 model BodyI18n {
   id           BigInt                        @id @default(autoincrement())
-  lang         LanguageCodes                 @unique(map: "BodyI18n_lang_unique_constraint")
+  lang         LanguageCodes
   body         String
   templateId   BigInt
   template     Template                      @relation(fields: [templateId], references: [id])
diff --git a/api/src/core/i18n/i18n/i18n.controller.ts b/api/src/core/i18n/i18n/i18n.controller.ts
index ea78794c6..6dbe2ebcf 100644
--- a/api/src/core/i18n/i18n/i18n.controller.ts
+++ b/api/src/core/i18n/i18n/i18n.controller.ts
@@ -1,4 +1,12 @@
-import { Body, Controller, Post } from '@nestjs/common';
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+} from '@nestjs/common';
 import { Template, TemplateType, Prisma } from '@prisma/client';
 import { PrismaService } from '../../../prisma.service';
 import { TransformerService } from '../../transformer/transformer.service';
@@ -23,7 +31,23 @@ export class I18nController {
   async addTemplate(
     @Body() templateData: Prisma.TemplateCreateInput,
   ): Promise<Template> {
-    return this.templateService.createTemplate(templateData);
+    const hasDuplicate = (arrayObj, colName) => {
+      var hash = Object.create(null);
+      return arrayObj.some((arr) => {
+        return (
+          arr[colName] && (hash[arr[colName]] || !(hash[arr[colName]] = true))
+        );
+      });
+    };
+    const isDuplicate: Boolean = hasDuplicate(
+      templateData.bodyI18n.createMany.data,
+      'lang',
+    );
+    if (isDuplicate) {
+      throw new BadRequestException('Duplicate language codes not allowed');
+    } else {
+      return this.templateService.createTemplate(templateData);
+    }
   }
 
   @Post('process')
diff --git a/api/src/core/search/search.controller.ts b/api/src/core/search/search.controller.ts
index cf0747ea6..137e9bd5e 100644
--- a/api/src/core/search/search.controller.ts
+++ b/api/src/core/search/search.controller.ts
@@ -5,17 +5,20 @@ import { TemplateService } from '../template/template.service';
 
 @Controller('search')
 export class SearchController {
-    constructor(
-        private readonly templateService: TemplateService,
-    ){}
+  constructor(private readonly templateService: TemplateService) {}
 
-    @Get('tag')
-    async searchTag(@Query() queryString: string): Promise<Template[]>{
-        return this.templateService.searchTag(queryString);
-    }
+  @Get('tag')
+  async searchTag(
+    @Query() queryString: { queryString: string },
+  ): Promise<Template[]> {
+    return this.templateService.searchTag(queryString.queryString);
+  }
 
-    @Get('body')
-    async searchTemplateBody(@Query() queryString: string): Promise<Template[]>{
-        return this.templateService.searchBody(queryString);
-    }
+  @Get('body')
+  async searchTemplateBody(
+    @Query() queryString: { queryString: string },
+  ): Promise<Template[]> {
+    console.log({ test: queryString.queryString });
+    return this.templateService.searchBody(queryString.queryString);
+  }
 }
diff --git a/api/src/core/template/template.service.ts b/api/src/core/template/template.service.ts
index 92878a5ff..b874b947c 100644
--- a/api/src/core/template/template.service.ts
+++ b/api/src/core/template/template.service.ts
@@ -13,6 +13,7 @@ export class TemplateService {
       where: userWhereUniqueInput,
       include: {
         transformers: true,
+        bodyI18n: true,
       },
     });
   }
@@ -73,6 +74,9 @@ export class TemplateService {
   async searchBody(queryString: string): Promise<Template[]> {
     return this.prisma.template.findMany({
       take: 200,
+      include: {
+        bodyI18n: true,
+      },
       where: {
         OR: [
           {
@@ -80,8 +84,10 @@ export class TemplateService {
               contains: queryString,
               mode: 'insensitive',
             },
+          },
+          {
             bodyI18n: {
-              every: {
+              some: {
                 body: {
                   contains: queryString,
                   mode: 'insensitive',