@tstdl/base 0.93.34 → 0.93.36

package/source/templates/renderers/handlebars.template-renderer.ts

@@ -0,0 +1,154 @@
+import { Singleton } from '#/injector/decorators.js';
+import type { ObjectLiteral, Record } from '#/types/index.js';
+import { memoizeSingle } from '#/utils/function/memoize.js';
+import { hasOwnProperty, mapObjectValues, mapObjectValuesAsync, objectEntries, objectValues } from '#/utils/object/object.js';
+import { assertDefined, isDefined, isFunction, isString } from '#/utils/type-guards.js';
+import type * as Handlebars from 'handlebars';
+import { TemplateResolverProvider } from '../template-resolver.provider.js';
+import type { TemplateField } from '../template.model.js';
+import type { TemplateRenderObject } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+
+export type HandlebarsTemplateHelperOptionsLocationItem = { line: number, column: number };
+
+export type HandlebarsTemplateHelperOptionsLocation = {
+  start: HandlebarsTemplateHelperOptionsLocationItem,
+  end: HandlebarsTemplateHelperOptionsLocationItem
+};
+
+export type HandlebarsTemplateHelperOptions = {
+  name: string,
+  location?: HandlebarsTemplateHelperOptionsLocation,
+  data?: Record<string>,
+  hash: Record<string>,
+  lookupProperty: (object: ObjectLiteral, propertyName: string) => unknown,
+  fn?: Handlebars.TemplateDelegate,
+  inverse?: Handlebars.TemplateDelegate
+};
+
+export type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
+export type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
+
+export type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | Handlebars.TemplateDelegate;
+export type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
+
+export type HandlebarsRendererOptions = {
+  strict?: boolean,
+  preventIndent?: boolean,
+  helpers?: HandlebarsTemplateHelpersObject,
+  partials?: HandlebarsTemplatePartialsObject
+};
+
+export type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
+
+const wrapHandlebarsTemplateHelper = memoizeSingle(_wrapHandlebarsTemplateHelper, { weak: true });
+
+@Singleton()
+export class HandlebarsTemplateRenderer extends TemplateRenderer<'handlebars', HandlebarsRendererOptions> {
+  private readonly templateResolverProvider: TemplateResolverProvider;
+  private readonly compileHandlebarsTemplate: typeof this._compileHandlebarsTemplate;
+
+  constructor(templateResolverProvider: TemplateResolverProvider) {
+    super();
+
+    this.templateResolverProvider = templateResolverProvider;
+    this.compileHandlebarsTemplate = memoizeSingle(this._compileHandlebarsTemplate, { weak: true }); // eslint-disable-line @typescript-eslint/unbound-method
+  }
+
+  canHandleType(type: string): boolean {
+    return type == 'handlebars';
+  }
+
+  async _render(renderObject: HandlebarsTemplateRenderObject, context: Record): Promise<string> {
+    const renderer = await this.compileHandlebarsTemplate(renderObject);
+    return renderer(context);
+  }
+
+  private async _compileHandlebarsTemplate(renderObject: HandlebarsTemplateRenderObject): Promise<Handlebars.TemplateDelegate> {
+    const { template, options = {} } = renderObject;
+
+    const allHelpers = getAllPartialHelpersDeep(renderObject);
+    const compile = await importHandlebarsCompile();
+
+    const renderer = compile(template, {
+      strict: options.strict ?? true,
+      preventIndent: options.preventIndent,
+      knownHelpers: isDefined(allHelpers) ? mapObjectValues(allHelpers, () => true) : undefined,
+      knownHelpersOnly: true
+    });
+
+    const wrappedHelpers = isDefined(allHelpers) ? mapObjectValues(allHelpers, wrapHandlebarsTemplateHelper) : undefined;
+    const normalizedPartials = isDefined(options.partials) ? await mapObjectValuesAsync(options.partials, async (partial) => this.normalizePartial(partial)) : undefined;
+
+    return (context?: any, runtimeOptions?: Handlebars.RuntimeOptions) => renderer(context, { helpers: wrappedHelpers, partials: normalizedPartials, ...runtimeOptions });
+  }
+
+  private async normalizePartial(partial: HandlebarsTemplatePartial): Promise<Handlebars.TemplateDelegate> {
+    if (isString(partial) || isFunction(partial)) {
+      return partial as Handlebars.TemplateDelegate;
+    }
+
+    const resolver = this.templateResolverProvider.get(partial.resolver);
+    return resolver.resolve(partial) as Promise<Handlebars.TemplateDelegate>;
+  }
+}
+
+function _wrapHandlebarsTemplateHelper(helper: HandlebarsTemplateHelper): Handlebars.HelperDelegate {
+  const wrapperName = `wrapped${helper.name.slice(0, 1).toUpperCase()}${helper.name.slice(1)}`;
+
+  const wrapper = {
+    [wrapperName](context: unknown, ...argsAndOptions: any[]): any {
+      const args = argsAndOptions.slice(0, -1);
+      const options = argsAndOptions[argsAndOptions.length - 1] as HandlebarsTemplateHelperOptions;
+
+      return helper(context, args, options);
+    }
+  }[wrapperName]!;
+
+  return wrapper;
+}
+
+function getAllPartialHelpersDeep(field: HandlebarsTemplateRenderObject | TemplateField<string, 'handlebars', HandlebarsRendererOptions>): HandlebarsTemplateHelpersObject | undefined {
+  const allHelpers = getPartialHelpersDeep(field);
+  const helpers: HandlebarsTemplateHelpersObject = {};
+
+  if (allHelpers.length == 0) {
+    return undefined;
+  }
+
+  for (const [key, helper] of allHelpers) {
+    if (hasOwnProperty(helpers, key) && helpers[key] != helper) {
+      throw new Error(`Template and partials reference different versions of helper "${key}".`);
+    }
+
+    helpers[key] = helper;
+  }
+
+  return helpers;
+}
+
+function getPartialHelpersDeep(partial: HandlebarsTemplateRenderObject | HandlebarsTemplatePartial): [string, HandlebarsTemplateHelper][] {
+  if (isString(partial) || isFunction(partial)) {
+    return [];
+  }
+
+  const entries = objectEntries(partial.options?.helpers ?? {});
+  const childEntries = objectValues(partial.options?.partials ?? {}).flatMap(getPartialHelpersDeep);
+
+  return [...entries, ...childEntries];
+}
+
+
+let handlebarsCompile: (typeof Handlebars)['compile'];
+
+async function importHandlebarsCompile(): Promise<(typeof Handlebars)['compile']> {
+  if (isDefined(handlebarsCompile)) {
+    return handlebarsCompile;
+  }
+
+  const handlebars = await import('handlebars') as any as Partial<typeof Handlebars> & { default?: Partial<typeof Handlebars> };
+  const compile = handlebars.compile ?? handlebars.default?.compile;
+  assertDefined(compile, 'Could not import handlebars.');
+
+  return (handlebarsCompile = compile); // eslint-disable-line require-atomic-updates
+}

package/source/templates/renderers/index.ts

@@ -0,0 +1,4 @@
+export * from './handlebars.template-renderer.js';
+export * from './jsx.template-renderer.js';
+export * from './mjml.template-renderer.js';
+export * from './string.template-renderer.js';

package/source/templates/renderers/jsx.template-renderer.tsx

@@ -0,0 +1,23 @@
+import { Singleton } from '#/injector/decorators.js';
+import { renderJsxAsync } from '#/jsx/render-to-string.js';
+import type { Record } from '#/types/index.js';
+import type { JsxTemplate } from '../resolvers/jsx.template-resolver.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+
+export type JsxTemplateRenderObject = TemplateRenderObject<'jsx', undefined, JsxTemplate>;
+
+@Singleton()
+export class JsxTemplateRenderer extends TemplateRenderer<'jsx', undefined> {
+  constructor() {
+    super();
+  }
+
+  canHandleType(type: string): boolean {
+    return (type == 'jsx');
+  }
+
+  async _render({ template }: JsxTemplateRenderObject, context: Record): Promise<TemplateRenderResult> {
+    return renderJsxAsync(template, context);
+  }
+}

package/source/templates/renderers/mjml.template-renderer.ts

@@ -0,0 +1,57 @@
+import { ForwardRef, Singleton } from '#/injector/decorators.js';
+import type { Record } from '#/types/index.js';
+import mjml2html from 'mjml';
+import type { MJMLParsingOptions } from 'mjml-core';
+import { TemplateRendererProvider } from '../template-renderer.provider.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+
+export type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
+  preprocessorOptions?: any
+};
+
+export type MjmlRendererString = 'mjml' | `mjml-${string}`;
+
+export type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions, string>;
+
+@Singleton()
+export class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererString, MjmlRendererOptions> {
+  private readonly rendererProvider: TemplateRendererProvider;
+
+  constructor(@ForwardRef(() => TemplateRendererProvider) rendererProvider: TemplateRendererProvider) {
+    super();
+
+    this.rendererProvider = rendererProvider;
+  }
+
+  canHandleType(type: string): boolean {
+    if (type == 'mjml') {
+      return true;
+    }
+
+    if (!type.startsWith('mjml-')) {
+      return false;
+    }
+
+    const parent = type.slice(5);
+    return this.rendererProvider.has(parent);
+  }
+
+  async _render({ renderer, template, options }: MjmlTemplateRenderObject, context: Record): Promise<TemplateRenderResult> {
+    if (renderer.length > 4) {
+      const parent = renderer.slice(5);
+      const parentRenderer = this.rendererProvider.get(parent);
+
+      const result = await parentRenderer.render({ template, renderer: parent, options: options?.preprocessorOptions }, context);
+
+      const preprocessedTemplate: MjmlTemplateRenderObject = {
+        renderer: 'mjml',
+        template: result
+      };
+
+      return this._render(preprocessedTemplate, context);
+    }
+
+    return mjml2html(template).html;
+  }
+}

package/source/templates/renderers/string.template-renderer.ts

@@ -0,0 +1,27 @@
+import { Singleton } from '#/injector/decorators.js';
+import type { Record } from '#/types/index.js';
+import { isString } from '#/utils/type-guards.js';
+import type { StringTemplate } from '../resolvers/string.template-resolver.js';
+import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
+import { TemplateRenderer } from '../template.renderer.js';
+
+export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined, StringTemplate>;
+
+@Singleton()
+export class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
+  constructor() {
+    super();
+  }
+
+  canHandleType(type: string): boolean {
+    return (type == 'string');
+  }
+
+  async _render({ template }: StringTemplateRenderObject, context: Record): Promise<TemplateRenderResult> {
+    if (isString(template)) {
+      return template;
+    }
+
+    return template(context);
+  }
+}

package/source/templates/resolvers/file.template-resolver.ts

@@ -0,0 +1,60 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { BadRequestError } from '#/errors/bad-request.error.js';
+import { InjectArg, Singleton } from '#/injector/decorators.js';
+import { type Resolvable, resolveArgumentType } from '#/injector/interfaces.js';
+import { StringProperty } from '#/schema/index.js';
+import type { TypedOmit } from '#/types/index.js';
+import { TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+
+export type FileTemplateProviderConfig = {
+  basePath?: string
+};
+
+export type FileTemplateProviderArgument = string;
+
+export const fileTemplateProviderConfig: FileTemplateProviderConfig = {};
+
+export class FileTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'file', Renderer, Options> {
+  @StringProperty()
+  templateFile: string;
+}
+
+@Singleton({
+  defaultArgumentProvider: () => fileTemplateProviderConfig.basePath
+})
+export class FileTemplateResolver extends TemplateResolver<FileTemplateField> implements Resolvable<FileTemplateProviderArgument> {
+  private readonly basePath: string;
+
+  declare readonly [resolveArgumentType]: FileTemplateProviderArgument;
+  constructor(@InjectArg() basePath: string) {
+    super();
+
+    this.basePath = path.resolve(basePath);
+  }
+
+  canHandle(resolver: string): boolean {
+    return (resolver == 'file');
+  }
+
+  async resolve(field: FileTemplateField): Promise<string> {
+    const filePath = path.resolve(this.basePath, field.templateFile);
+
+    if (!filePath.startsWith(this.basePath)) {
+      throw new BadRequestError(`Illegal file path. Must be inside "${this.basePath}".`);
+    }
+
+    return fs.readFile(filePath, { encoding: 'utf8' });
+  }
+}
+
+export function fileTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]> {
+  return { resolver: 'file', ...field };
+}
+
+export function configureFileTemplateResolver(config: Partial<FileTemplateProviderConfig> = {}): void {
+  fileTemplateProviderConfig.basePath = config.basePath ?? fileTemplateProviderConfig.basePath;
+}

package/source/templates/resolvers/index.ts

@@ -0,0 +1,3 @@
+export * from './file.template-resolver.js';
+export * from './jsx.template-resolver.js';
+export * from './string.template-resolver.js';

package/source/templates/resolvers/jsx.template-resolver.ts

@@ -0,0 +1,33 @@
+import { Singleton } from '#/injector/decorators.js';
+import { Method } from '#/schema/index.js';
+import type { PartialProperty, Record, TypedOmit } from '#/types/index.js';
+import type { ComponentClass, FunctionComponent } from 'preact';
+import { type Template, TemplateField, simpleTemplate } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+
+export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
+
+export class JsxTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+  @Method(null, null)
+  template: JsxTemplate<Context>;
+}
+
+@Singleton()
+export class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
+  canHandle(resolver: string): boolean {
+    return (resolver == 'jsx');
+  }
+
+  resolve(field: JsxTemplateField): JsxTemplate {
+    return field.template;
+  }
+}
+
+export function jsxTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: PartialProperty<TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>, 'renderer'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context> {
+  return { resolver: 'string', renderer: 'jsx', ...field };
+}
+
+export function simpleJsxTemplate<Context extends Record = any>(name: string, template: JsxTemplate<Context>): Template<{ template: true }, undefined, Context> {
+  return simpleTemplate(name, jsxTemplateField({ template }));
+}

package/source/templates/resolvers/string.template-resolver.ts

@@ -0,0 +1,28 @@
+import { Singleton } from '#/injector/decorators.js';
+import { Union } from '#/schema/index.js';
+import type { Record, TypedOmit } from '#/types/index.js';
+import { TemplateField } from '../template.model.js';
+import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
+import { TemplateResolver } from '../template.resolver.js';
+
+export type StringTemplate<Context extends Record = any> = string | ((context: Context) => string | Promise<string>);
+
+export class StringTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+  @Union(String, Function)
+  template: StringTemplate<Context>;
+}
+
+@Singleton()
+export class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
+  canHandle(resolver: string): boolean {
+    return (resolver == 'string');
+  }
+
+  resolve(field: StringTemplateField): StringTemplate<Record> {
+    return field.template;
+  }
+}
+
+export function stringTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context> {
+  return { resolver: 'string', ...field };
+}

package/source/templates/template-renderer.provider.ts

@@ -0,0 +1,32 @@
+import { inject, Singleton } from '#/injector/index.js';
+import type { TemplateRenderer } from './template.renderer.js';
+import { TEMPLATE_RENDERERS } from './tokens.js';
+
+@Singleton()
+export class TemplateRendererProvider {
+  private readonly renderers = new Set<TemplateRenderer>(inject(TEMPLATE_RENDERERS, undefined, { optional: true }) ?? []);
+
+  register(renderer: TemplateRenderer): void {
+    this.renderers.add(renderer);
+  }
+
+  has(type: string): boolean {
+    for (const renderer of this.renderers) {
+      if (renderer.canHandleType(type)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  get(type: string): TemplateRenderer {
+    for (const renderer of this.renderers) {
+      if (renderer.canHandleType(type)) {
+        return renderer;
+      }
+    }
+
+    throw new Error(`No renderer for ${type} registered.`);
+  }
+}

package/source/templates/template-resolver.provider.ts

@@ -0,0 +1,32 @@
+import { inject, Singleton } from '#/injector/index.js';
+import type { TemplateResolver } from './template.resolver.js';
+import { TEMPLATE_RESOLVERS } from './tokens.js';
+
+@Singleton()
+export class TemplateResolverProvider {
+  private readonly resolvers = new Set<TemplateResolver>(inject(TEMPLATE_RESOLVERS, undefined, { optional: true }) ?? []);
+
+  register(renderer: TemplateResolver): void {
+    this.resolvers.add(renderer);
+  }
+
+  has(type: string): boolean {
+    for (const renderer of this.resolvers) {
+      if (renderer.canHandle(type)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  get(type: string): TemplateResolver {
+    for (const renderer of this.resolvers) {
+      if (renderer.canHandle(type)) {
+        return renderer;
+      }
+    }
+
+    throw new Error(`No resolver for ${type} registered.`);
+  }
+}

package/source/templates/template.model.ts

@@ -0,0 +1,51 @@
+import { Any, any, Class, object, Optional, Property, StringProperty } from '#/schema/index.js';
+import type { PickBy, Record, SimplifyObject } from '#/types/index.js';
+
+export type TemplateContext<T extends Template> = Parameters<NonNullable<T[typeof templateContext]>>[0];
+
+declare const templateContext: unique symbol;
+
+@Class({ unknownProperties: any() })
+export class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> {
+  declare readonly [templateContext]?: (context: Context) => void;
+
+  @StringProperty()
+  resolver: Resolver;
+
+  @StringProperty()
+  renderer: Renderer;
+
+  @Any()
+  @Optional()
+  options?: Options;
+}
+
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> = SimplifyObject<
+  & { [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options, Context>; }
+  & { [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options, Context>; }
+>;
+
+export abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
+  declare readonly [templateContext]?: (context: Context) => void;
+
+  /** Name of template */
+  @StringProperty()
+  name: string;
+
+  @Property(object({}, { unknownProperties: TemplateField }))
+  fields: TemplateFields<Fields, string, string, any, Context>;
+
+  @Any()
+  @Optional()
+  options?: TemplateOptions;
+}
+
+export function simpleTemplate<Context extends Record = any, Options = any>(name: string, template: TemplateField<string, string, any, Context>, options?: Options): Template<{ template: true }, Options, Context> {
+  return {
+    name,
+    fields: {
+      template
+    },
+    options
+  };
+}

package/source/templates/template.provider.ts

@@ -0,0 +1,5 @@
+import type { Template } from './template.model.js';
+
+export abstract class TemplateProvider {
+  abstract get(key: string): Template | Promise<Template>;
+}

package/source/templates/template.renderer.ts

@@ -0,0 +1,36 @@
+import type { SchemaTestable } from '#/schema/index.js';
+import { Schema } from '#/schema/index.js';
+import type { Record } from '#/types/index.js';
+import { isDefined } from '#/utils/type-guards.js';
+
+export type TemplateRenderResult = string;
+
+export type TemplateRenderObject<Renderer extends string = string, Options = any, V = unknown> = {
+  renderer: Renderer,
+  template: V,
+  contextSchema?: SchemaTestable<Record>,
+  options?: Options
+};
+
+export type TemplateRendererString = typeof templateRendererString;
+export type TemplateRendererOptions = typeof templateRendererOptions;
+
+export const templateRendererString: unique symbol = Symbol('templateRendererString');
+export const templateRendererOptions: unique symbol = Symbol('templateRendererOptions');
+
+export abstract class TemplateRenderer<Renderer extends string = string, Options = any> {
+  declare readonly [templateRendererString]: Renderer;
+  declare readonly [templateRendererOptions]: Options;
+
+  async render(template: TemplateRenderObject<Renderer, Options>, context?: Record): Promise<TemplateRenderResult> {
+    const parsedContext = isDefined(template.contextSchema)
+      ? Schema.parse(template.contextSchema, context)
+      : context;
+
+    return this._render(template, parsedContext ?? {});
+  }
+
+  abstract canHandleType(type: string): boolean;
+
+  protected abstract _render(renderObject: TemplateRenderObject<Renderer, Options>, context: Record): TemplateRenderResult | Promise<TemplateRenderResult>;
+}

package/source/templates/template.resolver.ts

@@ -0,0 +1,6 @@
+import type { TemplateField } from './template.model.js';
+
+export abstract class TemplateResolver<T extends TemplateField = TemplateField, V = unknown> {
+  abstract canHandle(resolver: string): boolean;
+  abstract resolve(field: T): V | Promise<V>;
+}

package/source/templates/template.service.ts

@@ -0,0 +1,50 @@
+import { Singleton } from '#/injector/decorators.js';
+import { inject } from '#/injector/inject.js';
+import type { Record } from '#/types/index.js';
+import { objectEntries } from '#/utils/object/object.js';
+import { _throw } from '#/utils/throw.js';
+import { isString } from '#/utils/type-guards.js';
+import { TemplateRendererProvider } from './template-renderer.provider.js';
+import { TemplateResolverProvider } from './template-resolver.provider.js';
+import type { Template, TemplateContext } from './template.model.js';
+import { TemplateProvider } from './template.provider.js';
+
+export type TemplateServiceRenderResult<T extends Template = Template> = {
+  name: string,
+  fields: Record<keyof T['fields'], string>,
+  options: T['options']
+};
+
+@Singleton()
+export class TemplateService {
+  private readonly templateProvider = inject(TemplateProvider, undefined, { optional: true }) ?? { get: () => _throw(new Error('No template provider provided. Cannot render template-keys.')) };
+  private readonly templateRendererProvider = inject(TemplateRendererProvider);
+  private readonly templateResolverProvider = inject(TemplateResolverProvider);
+
+  async get<T extends Template = Template>(key: string): Promise<T> {
+    const template = await this.templateProvider.get(key);
+    return template as T;
+  }
+
+  async render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: TemplateContext<T>): Promise<TemplateServiceRenderResult<T>> {
+    const template = isString(keyOrTemplate) ? await this.get(keyOrTemplate) : keyOrTemplate;
+
+    const result: TemplateServiceRenderResult<T> = {
+      name: template.name,
+      fields: {} as any,
+      options: template.options
+    };
+
+    for (const [key, field] of objectEntries(template.fields)) {
+      const resolver = this.templateResolverProvider.get(field.resolver);
+      const renderer = this.templateRendererProvider.get(field.renderer);
+
+      const templateString = await resolver.resolve(field);
+      const resultString = await renderer.render({ renderer: field.renderer, template: templateString, options: field.options }, templateContext);
+
+      result.fields[key as keyof T['fields']] = resultString;
+    }
+
+    return result;
+  }
+}

package/source/templates/tokens.ts

@@ -0,0 +1,6 @@
+import { injectionToken } from '#/injector/token.js';
+import type { TemplateRenderer } from './template.renderer.js';
+import type { TemplateResolver } from './template.resolver.js';
+
+export const TEMPLATE_RENDERERS = injectionToken<TemplateRenderer[]>('template renderers');
+export const TEMPLATE_RESOLVERS = injectionToken<TemplateResolver[]>('template resolvers');

package/source/templates/types/index.ts

@@ -0,0 +1 @@
+export * from './jsx.intrinsic-elements.js';

package/source/templates/types/jsx.intrinsic-elements.ts

@@ -0,0 +1,7 @@
+declare module 'preact' {
+  namespace JSX {
+    interface IntrinsicElements {
+      [key: string]: any;
+    }
+  }
+}

package/source/test/drizzle/0000_natural_cannonball.sql

@@ -0,0 +1,9 @@
+CREATE TABLE "test"."test" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"title" text NOT NULL,
+	"content" text NOT NULL,
+	"tags" text NOT NULL,
+	"language" text NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX "test_parade_idx" ON "test"."test" USING bm25 ("id","language","title","content","tags",(("title" || ' ' || "content" || ' ' || "tags")::pdb.simple('alias=search_text')),(('foo')::pdb.simple('alias=foo'))) WITH (key_field='id',mutable_segment_rows=12);