@tstdl/base 0.93.178 → 0.93.180

package/test/drizzle/0001_closed_the_captain.sql

@@ -1,2 +0,0 @@
-DROP INDEX "test"."test_parade_idx";--> 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');

package/test/drizzle/meta/0001_snapshot.json

@@ -1,117 +0,0 @@
-{
-  "id": "68a0bdde-47d3-4390-b409-27a74dd269f3",
-  "prevId": "bbffc0f2-678b-42e9-8121-1731a04b8987",
-  "version": "7",
-  "dialect": "postgresql",
-  "tables": {
-    "test.test": {
-      "name": "test",
-      "schema": "test",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "gen_random_uuid()"
-        },
-        "title": {
-          "name": "title",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "content": {
-          "name": "content",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "tags": {
-          "name": "tags",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "language": {
-          "name": "language",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {
-        "test_parade_idx": {
-          "name": "test_parade_idx",
-          "columns": [
-            {
-              "expression": "id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "\"language\"",
-              "asc": true,
-              "isExpression": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "\"title\"",
-              "asc": true,
-              "isExpression": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "\"content\"",
-              "asc": true,
-              "isExpression": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "\"tags\"",
-              "asc": true,
-              "isExpression": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "((\"title\" || ' ' || \"content\" || ' ' || \"tags\")::pdb.simple('alias=search_text'))",
-              "asc": true,
-              "isExpression": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "(('foo')::pdb.simple('alias=foo'))",
-              "asc": true,
-              "isExpression": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "bm25",
-          "with": {
-            "key_field": "'id'"
-          }
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    }
-  },
-  "enums": {},
-  "schemas": {},
-  "sequences": {},
-  "roles": {},
-  "policies": {},
-  "views": {},
-  "_meta": {
-    "columns": {},
-    "schemas": {},
-    "tables": {}
-  }
-}

package/utils/cryptography.d.ts

@@ -1,137 +0,0 @@
-import type { BinaryData, TypedExtract } from '../types/index.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';
-export type SymmetricAlgorithm = `AES-${AesMode}`;
-export type AsymmetricAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP' | 'ECDSA' | 'ECDH' | 'NODE-DSA' | 'NODE-DH' | 'NODE-ED25519' | 'NODE-ED448';
-export type CryptionAlgorithm = Parameters<typeof globalThis.crypto.subtle.encrypt>[0];
-export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
-export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
-export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
-export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
-export type Key = JsonWebKey | BinaryData<ArrayBuffer>;
-export type ScryptOptions = {
-    cost?: number;
-    blockSize?: number;
-    parallelization?: number;
-    maximumMemory?: number;
-};
-export interface CryptionResult {
-    toBuffer(): Promise<ArrayBuffer>;
-    toHex(): Promise<string>;
-    toBase64(): Promise<string>;
-    toBase64Url(): Promise<string>;
-    toZBase32(): Promise<string>;
-}
-export interface DecryptionResult extends CryptionResult {
-    toUtf8(): Promise<string>;
-}
-export type DigestResult = CryptionResult;
-export type SignResult = CryptionResult;
-/**
- * Encrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to encrypt. Encodes string to utf8
- */
-export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData<ArrayBuffer> | string): CryptionResult;
-/**
- * Decrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to decrypt
- */
-export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData<ArrayBuffer>): DecryptionResult;
-/**
- * Hashes data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param data data to encrypt. Encodes string to utf8
- */
-export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData<ArrayBuffer> | string): DigestResult;
-/**
- * Signs data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to sign
- */
-export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData<ArrayBuffer> | string): SignResult;
-/**
- * Verifies data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param signature signature
- * @param data data to verify using provided signature
- */
-export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData<ArrayBuffer> | string, data: BinaryData<ArrayBuffer> | string): Promise<boolean>;
-/**
- * Imports a HMAC CryptoKey
- * @param algorithm hash algorithm
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importHmacKey(algorithm: HashAlgorithmIdentifier, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Imports a CryptoKey for symmetric encryption
- * @param algorithm symmetric algorithm
- * @param length key length
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importSymmetricKey(algorithm: SymmetricAlgorithm, length: 128 | 192 | 256, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Imports an ECDSA CryptoKey
- * @param curve ECDSA curve
- * @param key JWK or DER encoded key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importEcdsaKey(curve: EcdsaCurve, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Import a HKDF CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importHkdfKey(key: BinaryData<ArrayBuffer> | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Import a pbkdf2 CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export declare function importPbkdf2Key(key: BinaryData<ArrayBuffer> | string, extractable?: boolean): Promise<CryptoKey>;
-/**
- * Generates a new ECDSA CryptoKeyPair
- * @param curve ECDSA cruve to use
- * @param extractable whether the key can be used for exportKey
- * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
- */
-export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolean, usages?: TypedExtract<KeyUsage, 'sign' | 'verify'>[]): Promise<CryptoKeyPair>;
-/**
- * Convenience wrapper for HKDF derivation
- * @param baseKey The imported HKDF key
- * @param lengths Array of lengths for each derived secret
- * @param info Contextual string to prevent different apps from deriving the same keys
- * @param salt Optional salt (usually empty if the input key is high-entropy)
- * @param hash Hash algorithm to use
- */
-export declare function deriveHkdfSecrets<const Lengths extends readonly number[]>(baseKey: CryptoKey, lengths: Lengths, info?: string | BinaryData<ArrayBuffer>, salt?: BinaryData<ArrayBuffer>, hash?: HashAlgorithm): Promise<Readonly<import("type-fest").If<import("type-fest").IsAny<Lengths["length"]>, Uint8Array<ArrayBuffer>[], import("type-fest").If<import("type-fest").IsNever<Lengths["length"]>, [], number extends import("type-fest").If<import("type-fest").IsNegative<Lengths["length"]>, 0, Lengths["length"]> ? Uint8Array<ArrayBuffer>[] : import("type-fest").If<import("type-fest").IsNegative<Lengths["length"]>, 0, Lengths["length"]> extends infer T ? T extends import("type-fest").If<import("type-fest").IsNegative<Lengths["length"]>, 0, Lengths["length"]> ? T extends 0 ? [] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 1 ? [Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 2 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 3 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 4 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 5 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 6 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 7 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 8 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 9 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : number extends T ? Uint8Array<ArrayBuffer>[] : T extends 10 ? [Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>] : /*elided*/ any : never : never>>>>;
-/**
- * Generates a pbkdf2 CryptoKey
- * @param extractable whether the key can be used for exportKey
- */
-export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
-/**
- * Derive byte array from key
- * @param length length in bytes
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- */
-export declare function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: number): Promise<Uint8Array>;
-/**
- * Derive multiply byte arrays from key
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array
- * @param count how many Uint8Arrays to derive
- */
-export declare function deriveBytesMultiple<const Lengths extends readonly number[]>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, lengths: Lengths): Promise<ReadonlyTuple<Uint8Array<ArrayBuffer>, Lengths['length']>>;
-export declare function deriveBytesMultiple<const C extends number>(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: C, count: number): Promise<ReadonlyTuple<Uint8Array<ArrayBuffer>, C>>;

package/utils/cryptography.js

@@ -1,201 +0,0 @@
-import { createArray } from './array/array.js';
-import { encodeBase64, encodeBase64Url } from './base64.js';
-import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { getRandomBytes } from './random.js';
-import { isArray, isDefined, isString } from './type-guards.js';
-import { zBase32Encode } from './z-base32.js';
-/**
- * Encrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to encrypt. Encodes string to utf8
- */
-export function encrypt(algorithm, key, data) {
-    const bytes = isString(data) ? encodeUtf8(data) : data;
-    const encryptedBuffer = globalThis.crypto.subtle.encrypt(algorithm, key, bytes);
-    return {
-        toBuffer: async () => await encryptedBuffer,
-        toHex: async () => encodeHex(await encryptedBuffer),
-        toBase64: async () => encodeBase64(await encryptedBuffer),
-        toBase64Url: async () => encodeBase64Url(await encryptedBuffer),
-        toZBase32: async () => zBase32Encode(await encryptedBuffer),
-    };
-}
-/**
- * Decrypt data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to decrypt
- */
-export function decrypt(algorithm, key, bytes) {
-    const decryptedBuffer = globalThis.crypto.subtle.decrypt(algorithm, key, bytes);
-    return {
-        toBuffer: async () => await decryptedBuffer,
-        toHex: async () => encodeHex(await decryptedBuffer),
-        toBase64: async () => encodeBase64(await decryptedBuffer),
-        toBase64Url: async () => encodeBase64Url(await decryptedBuffer),
-        toZBase32: async () => zBase32Encode(await decryptedBuffer),
-        toUtf8: async () => decodeText(await decryptedBuffer),
-    };
-}
-/**
- * Hashes data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param data data to encrypt. Encodes string to utf8
- */
-export function digest(algorithm, data) {
-    const bytes = isString(data) ? encodeUtf8(data) : data;
-    const arrayBufferPromise = globalThis.crypto.subtle.digest(algorithm, bytes);
-    const result = {
-        toBuffer: async () => await arrayBufferPromise,
-        toHex: async () => encodeHex(await arrayBufferPromise),
-        toBase64: async () => encodeBase64(await arrayBufferPromise),
-        toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-        toZBase32: async () => zBase32Encode(await arrayBufferPromise),
-    };
-    return result;
-}
-/**
- * Signs data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param data data to sign
- */
-export function sign(algorithm, key, data) {
-    const bytes = isString(data) ? encodeUtf8(data) : data;
-    const arrayBufferPromise = globalThis.crypto.subtle.sign(algorithm, key, bytes);
-    const result = {
-        toBuffer: async () => await arrayBufferPromise,
-        toHex: async () => encodeHex(await arrayBufferPromise),
-        toBase64: async () => encodeBase64(await arrayBufferPromise),
-        toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-        toZBase32: async () => zBase32Encode(await arrayBufferPromise),
-    };
-    return result;
-}
-/**
- * Verifies data
- * @param algorithm algorithm as supported by Web Crypto API
- * @param key key
- * @param signature signature
- * @param data data to verify using provided signature
- */
-export async function verify(algorithm, key, signature, data) {
-    const signatureBytes = isString(signature) ? encodeUtf8(signature) : signature;
-    const dataBytes = isString(data) ? encodeUtf8(data) : data;
-    return await globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
-}
-/**
- * Imports a HMAC CryptoKey
- * @param algorithm hash algorithm
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importHmacKey(algorithm, key, extractable = false) {
-    const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    if (isBinaryKey(binaryKey)) {
-        return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
-    }
-    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
-}
-/**
- * Imports a CryptoKey for symmetric encryption
- * @param algorithm symmetric algorithm
- * @param length key length
- * @param key JWK or binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importSymmetricKey(algorithm, length, key, extractable = false) {
-    const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    if (isBinaryKey(binaryKey)) {
-        return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
-    }
-    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
-}
-/**
- * Imports an ECDSA CryptoKey
- * @param curve ECDSA curve
- * @param key JWK or DER encoded key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importEcdsaKey(curve, key, extractable = false) {
-    const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    if (isBinaryKey(binaryKey)) {
-        return await globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
-    }
-    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
-}
-/**
- * Import a HKDF CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importHkdfKey(key, extractable = false) {
-    const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HKDF' }, extractable, ['deriveKey', 'deriveBits']);
-}
-/**
- * Import a pbkdf2 CryptoKey
- * @param key binary key
- * @param extractable whether the key can be used for exportKey
- */
-export async function importPbkdf2Key(key, extractable = false) {
-    const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
-}
-/**
- * Generates a new ECDSA CryptoKeyPair
- * @param curve ECDSA cruve to use
- * @param extractable whether the key can be used for exportKey
- * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
- */
-export async function generateEcdsaKey(curve, extractable = false, usages = ['sign', 'verify']) {
-    return await globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
-}
-/**
- * Convenience wrapper for HKDF derivation
- * @param baseKey The imported HKDF key
- * @param lengths Array of lengths for each derived secret
- * @param info Contextual string to prevent different apps from deriving the same keys
- * @param salt Optional salt (usually empty if the input key is high-entropy)
- * @param hash Hash algorithm to use
- */
-export async function deriveHkdfSecrets(baseKey, lengths, info = '', salt = new Uint8Array(), hash = 'SHA-512') {
-    const infoBytes = isString(info) ? encodeUtf8(info) : info;
-    const algorithm = { name: 'HKDF', hash, salt, info: infoBytes };
-    return await deriveBytesMultiple(algorithm, baseKey, lengths);
-}
-/**
- * Generates a pbkdf2 CryptoKey
- * @param extractable whether the key can be used for exportKey
- */
-export async function generatePbkdf2Key(extractable = false) {
-    const key = getRandomBytes(16);
-    return await importPbkdf2Key(key, extractable);
-}
-/**
- * Derive byte array from key
- * @param length length in bytes
- * @param algorithm algorithm to derive with
- * @param baseKey key to derive from
- */
-export async function deriveBytes(algorithm, baseKey, length) {
-    const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, length * 8);
-    return new Uint8Array(bytes);
-}
-export async function deriveBytesMultiple(algorithm, baseKey, lengthOrLengths, countOrNothing) {
-    const lengths = isArray(lengthOrLengths) ? lengthOrLengths : createArray(countOrNothing, () => lengthOrLengths);
-    const totalBits = lengths.reduce((sum, length) => sum + length, 0) * 8;
-    const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
-    const arrays = [];
-    for (let i = 0; i < bytes.byteLength;) {
-        const slice = bytes.slice(i, i + lengths[arrays.length]);
-        const array = new Uint8Array(slice);
-        arrays.push(array);
-        i += slice.byteLength;
-    }
-    return arrays;
-}
-function isBinaryKey(key) {
-    return isDefined(key.byteLength);
-}