@tstdl/base 0.83.1 → 0.83.3

package/.eslintrc.cjs

@@ -1,4 +1,5 @@
 module.exports = {
+  root: true,
   env: {
     browser: true,
     es2022: true,
@@ -34,6 +35,7 @@ module.exports = {
     '@typescript-eslint/explicit-module-boundary-types': 'off',
     '@typescript-eslint/indent': 'off',
     '@typescript-eslint/init-declarations': 'off',
+    '@typescript-eslint/lines-around-comment': 'off',
     '@typescript-eslint/lines-between-class-members': ['warn', 'always', { exceptAfterSingleLine: true }],
     '@typescript-eslint/method-signature-style': 'off',
     '@typescript-eslint/no-confusing-void-expression': ['error', { ignoreArrowShorthand: true, ignoreVoidOperator: true }],
@@ -92,7 +94,7 @@ module.exports = {
     'function-paren-newline': ['warn', 'consistent'],
     'generator-star-spacing': ['off', { before: false, after: true }],
     'id-length': 'off',
-    'indent': ['error', 2, { SwitchCase: 1 }],
+    'indent': 'off',
     'init-declarations': 'off',
     'line-comment-position': 'off',
     'linebreak-style': ['error', 'unix'],
@@ -182,9 +184,11 @@ module.exports = {
         'protected-static-field',
         'public-static-field',
 
+        /*
         'private-decorated-field',
         'protected-decorated-field',
         'public-decorated-field',
+        */
 
         '#private-instance-field',
         'private-instance-field',
@@ -203,7 +207,7 @@ module.exports = {
         'instance-field',
         'abstract-field',
 
-        'decorated-field',
+        // 'decorated-field',
 
         'field',
 
@@ -213,9 +217,11 @@ module.exports = {
         'protected-static-get',
         'public-static-get',
 
+        /*
         'private-decorated-get',
         'protected-decorated-get',
         'public-decorated-get',
+        */
 
         '#private-instance-get',
         'private-instance-get',
@@ -234,7 +240,7 @@ module.exports = {
         'instance-get',
         'abstract-get',
 
-        'decorated-get',
+        // 'decorated-get',
 
         'get',
 
@@ -244,9 +250,11 @@ module.exports = {
         'protected-static-set',
         'public-static-set',
 
+        /*
         'private-decorated-set',
         'protected-decorated-set',
         'public-decorated-set',
+        */
 
         '#private-instance-set',
         'private-instance-set',
@@ -265,7 +273,7 @@ module.exports = {
         'instance-set',
         'abstract-set',
 
-        'decorated-set',
+        // 'decorated-set',
 
         'set',
 
@@ -285,9 +293,11 @@ module.exports = {
         'private-static-method',
         '#private-static-method',
 
+        /*
         'public-decorated-method',
         'protected-decorated-method',
         'private-decorated-method',
+        */
 
         'public-instance-method',
         'protected-instance-method',
@@ -306,7 +316,7 @@ module.exports = {
         'instance-method',
         'abstract-method',
 
-        'decorated-method',
+        // 'decorated-method',
 
         'method'
       ]

package/authentication/server/authentication.service.js

@@ -271,11 +271,10 @@ let AuthenticationService = class AuthenticationService2 {
   }
   async deriveSigningSecrets() {
     const key = await (0, import_cryptography.importPbkdf2Key)(this.secret);
-    const hash = await globalThis.crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() }, key, SIGNING_SECRETS_LENGTH * 3);
-    const bufferSize = SIGNING_SECRETS_LENGTH / 8;
-    this.derivedTokenSigningSecret = new Uint8Array(hash.slice(0, bufferSize));
-    this.derivedRefreshTokenSigningSecret = new Uint8Array(hash.slice(bufferSize, bufferSize * 2));
-    this.derivedSecretResetTokenSigningSecret = new Uint8Array(hash.slice(bufferSize * 2));
+    const [derivedTokenSigningSecret, derivedRefreshTokenSigningSecret, derivedSecretResetTokenSigningSecret] = await (0, import_cryptography.deriveBytesMultiple)(3, SIGNING_SECRETS_LENGTH / 8, { name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() }, key);
+    this.derivedTokenSigningSecret = derivedTokenSigningSecret;
+    this.derivedRefreshTokenSigningSecret = derivedRefreshTokenSigningSecret;
+    this.derivedSecretResetTokenSigningSecret = derivedSecretResetTokenSigningSecret;
   }
   async getHash(secret, salt) {
     const key = await (0, import_cryptography.importPbkdf2Key)(secret);

package/examples/mail/templates/hello-name.d.ts

@@ -1,2 +1,2 @@
-declare const template: import("../../../mail/index.js").MailTemplate;
+declare const template: import("../../../mail/index.js").MailTemplate<object>;
 export default template;

package/examples/pdf/templates/hello-name.d.ts

@@ -1,2 +1,2 @@
-declare const template: import("../../../pdf/pdf.service.js").PdfTemplate;
+declare const template: import("../../../pdf/pdf.service.js").PdfTemplate<any>;
 export default template;

package/examples/template/templates/hello-jsx.d.ts

@@ -1,2 +1,2 @@
-export declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any>;
+export declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, any>;
 export default template;

package/examples/template/templates/hello-name.d.ts

@@ -1,2 +1,2 @@
-declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any>;
+declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, any>;
 export default template;

package/mail/mail.service.d.ts

@@ -14,5 +14,5 @@ export declare class MailService {
     send(mailData: MailData): Promise<MailSendResult>;
     /** @deprecated internal */
     send(mailData: MailData, templateName?: string): Promise<MailSendResult>;
-    sendTemplate(keyOrTemplate: string | MailTemplate, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: object): Promise<MailSendResult>;
+    sendTemplate<Context extends object>(keyOrTemplate: string | MailTemplate<Context>, mailData: TypedOmit<MailData, 'content' | 'subject'>, templateContext?: Context): Promise<MailSendResult>;
 }

package/mail/models/mail-template.model.d.ts

@@ -1,11 +1,11 @@
 import type { Template, TemplateField } from '../../templates/template.model.js';
-export type MailTemplate = Template<{
+export type MailTemplate<Context extends object = any> = Template<{
     subject: false;
     html: false;
     text: false;
-}, undefined>;
-export declare function mailTemplate(name: string, fields: {
+}, undefined, Context>;
+export declare function mailTemplate<Context extends object>(name: string, fields: {
     subject?: TemplateField;
     html?: TemplateField;
     text?: TemplateField;
-}): MailTemplate;
+}): MailTemplate<Context>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.1",
+  "version": "0.83.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/pdf/pdf.service.d.ts

@@ -45,11 +45,11 @@ export declare class PdfRenderOptions {
     timeout?: number;
 }
 export type PdfTemplateOptions = PdfRenderOptions;
-export declare class PdfTemplate extends Template<{
+export declare class PdfTemplate<Context extends object = any> extends Template<{
     header: false;
     body: true;
     footer: false;
-}, PdfRenderOptions> {
+}, PdfRenderOptions, Context> {
     options?: PdfTemplateOptions;
 }
 export type PdfServiceOptions = {
@@ -101,7 +101,7 @@ export declare class PdfService implements AsyncDisposable, AfterResolve, Inject
      * @param options additional options, overwrites options specified in template
      * @returns pdf bytes
      */
-    renderTemplateStream(keyOrTemplate: string | PdfTemplate, templateContext?: object, options?: PdfRenderOptions): ReadableStream<Uint8Array>;
+    renderTemplateStream<Context extends object>(keyOrTemplate: string | PdfTemplate<Context>, templateContext?: Context, options?: PdfRenderOptions): ReadableStream<Uint8Array>;
     /**
      * Renders a template to pdf
      * @param key template key

package/templates/template.model.d.ts

@@ -1,4 +1,6 @@
 import type { PickBy, Record, SimplifyObject } from '../types.js';
+export type TemplateContext<T extends Template> = T[typeof templateContext];
+export declare const templateContext: unique symbol;
 export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any> {
     resolver: Resolver;
     renderer: Renderer;
@@ -9,7 +11,8 @@ export type TemplateFields<Fields extends Record<string, boolean>, Resolver exte
 } & {
     [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options>;
 }>;
-export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any> {
+export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends object = any> {
+    readonly [templateContext]?: Context;
     /** name of template */
     name: string;
     fields: TemplateFields<Fields>;

package/templates/template.model.js

@@ -20,7 +20,8 @@ var template_model_exports = {};
 __export(template_model_exports, {
   Template: () => Template,
   TemplateField: () => TemplateField,
-  simpleTemplate: () => simpleTemplate
+  simpleTemplate: () => simpleTemplate,
+  templateContext: () => templateContext
 });
 module.exports = __toCommonJS(template_model_exports);
 var import_schema = require("../schema/index.js");
@@ -38,6 +39,7 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
+const templateContext = Symbol("templateData");
 let TemplateField = class TemplateField2 {
   resolver;
   renderer;

package/templates/template.service.d.ts

@@ -1,7 +1,7 @@
 import type { Record } from '../types.js';
 import { TemplateRendererProvider } from './template-renderer.provider.js';
 import { TemplateResolverProvider } from './template-resolver.provider.js';
-import type { Template } from './template.model.js';
+import type { Template, TemplateContext } from './template.model.js';
 import { TemplateProvider } from './template.provider.js';
 export type TemplateServiceRenderResult<T extends Template = Template> = {
     name: string;
@@ -14,5 +14,5 @@ export declare class TemplateService {
     private readonly templateResolverProvider;
     constructor(templateProvider: TemplateProvider | undefined, templateRendererProvider: TemplateRendererProvider, templateResolverProvider: TemplateResolverProvider);
     get<T extends Template = Template>(key: string): Promise<T>;
-    render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: object): Promise<TemplateServiceRenderResult<T>>;
+    render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: TemplateContext<T>): Promise<TemplateServiceRenderResult<T>>;
 }

package/types.d.ts

@@ -83,10 +83,10 @@ type FromEntriesEntryValue<T extends readonly (readonly [any, any])[], K> = Extr
 export type FromEntries<T> = T extends readonly (readonly [infer Key, any])[] ? {
     [K in Cast<Key, PropertyKey>]: Fallback<FromEntriesEntryValue<T, K>, T[number][1]>;
 } : never;
-export type Writable<T> = {
+export type Writable<T> = T extends readonly (infer U)[] ? U[] : {
     -readonly [P in keyof T]: T[P];
 };
-export type DeepWritable<T> = {
+export type DeepWritable<T> = T extends readonly (infer U)[] ? DeepWritable<U>[] : {
     -readonly [P in keyof T]: DeepWritable<T[P]>;
 };
 export type RequiredKeys<T> = {

package/utils/cryptography.d.ts

@@ -1,4 +1,5 @@
 import type { BinaryData, TypedExtract } from '../types.js';
+import type { ReadonlyTuple } from 'type-fest';
 export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
 export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
 export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
@@ -104,3 +105,13 @@ export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolea
  * @param extractable whether the key can be used for exportKey
  */
 export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
+type AlgorithmParameter = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
+/**
+ * derive multiply byte arrays
+ * @param count how many Uint8Arrays to dervice
+ * @param length length of each Uint8Array in bytes
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ */
+export declare function deriveBytesMultiple<C extends number>(count: C, length: number, algorithm: AlgorithmParameter, baseKey: CryptoKey): Promise<ReadonlyTuple<Uint8Array, C>>;
+export {};

package/utils/cryptography.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var cryptography_exports = {};
 __export(cryptography_exports, {
   decrypt: () => decrypt,
+  deriveBytesMultiple: () => deriveBytesMultiple,
   digest: () => digest,
   encrypt: () => encrypt,
   generateEcdsaKey: () => generateEcdsaKey,
@@ -31,6 +32,7 @@ __export(cryptography_exports, {
   verify: () => verify
 });
 module.exports = __toCommonJS(cryptography_exports);
+var import_array = require("./array/array.js");
 var import_base64 = require("./base64.js");
 var import_encoding = require("./encoding.js");
 var import_random = require("./random.js");
@@ -120,6 +122,11 @@ async function generatePbkdf2Key(extractable = false) {
   const key = (0, import_random.getRandomBytes)(16);
   return importPbkdf2Key(key, extractable);
 }
+async function deriveBytesMultiple(count, length, algorithm, baseKey) {
+  const totalBits = count * length * 8;
+  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
+  return (0, import_array.createArray)(count, (index) => new Uint8Array(bytes.slice(index * length, index * length + length)));
+}
 function isBinaryKey(key) {
   return (0, import_type_guards.isDefined)(key.byteLength);
 }