@elaraai/east-node-std 0.0.1-beta.0

package/dist/crypto.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { StringType, IntegerType, BlobType } from "@elaraai/east";
+import type { PlatformFunction, PlatformFunctionDef } from "@elaraai/east/internal";
+/**
+ * Generates cryptographically secure random bytes.
+ *
+ * Produces random bytes using a cryptographically secure pseudo-random number generator (CSPRNG).
+ * Suitable for generating encryption keys, initialization vectors, tokens, and other security-sensitive
+ * random data.
+ *
+ * This is a platform function for the East language, enabling secure random generation
+ * in East programs running on Node.js.
+ *
+ * @param length - The number of random bytes to generate (must be positive)
+ * @returns Random bytes as a Blob (Uint8Array)
+ *
+ * @throws {EastError} When random generation fails:
+ * - Negative or invalid length
+ * - System entropy pool unavailable
+ *
+ * @example
+ * ```ts
+ * const generateToken = East.function([], BlobType, $ => {
+ *     return Crypto.randomBytes(32n);  // 256-bit token
+ * });
+ * ```
+ */
+export declare const crypto_random_bytes: PlatformFunctionDef<[typeof IntegerType], typeof BlobType>;
+/**
+ * Computes SHA-256 hash of a string.
+ *
+ * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+ * the result as a lowercase hexadecimal string (64 characters). SHA-256 is a one-way
+ * hash function commonly used for data integrity verification.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running on Node.js.
+ *
+ * @param data - The string to hash (will be UTF-8 encoded)
+ * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+ *
+ * @example
+ * ```ts
+ * const hashPassword = East.function([StringType], StringType, ($, password) => {
+ *     return Crypto.hashSha256(password);
+ *     // Returns: "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+ * });
+ * ```
+ */
+export declare const crypto_hash_sha256: PlatformFunctionDef<[typeof StringType], typeof StringType>;
+/**
+ * Computes SHA-256 hash of binary data.
+ *
+ * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+ * as raw bytes (32 bytes / 256 bits). This is the binary variant of {@link crypto_hash_sha256},
+ * useful when working with binary protocols or when you need the raw hash bytes.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running on Node.js.
+ *
+ * @param data - The binary data to hash (Blob/Uint8Array)
+ * @returns The SHA-256 hash as binary data (32 bytes)
+ *
+ * @example
+ * ```ts
+ * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+ *     return Crypto.hashSha256Bytes(fileData);
+ *     // Returns: 32 bytes of hash data
+ * });
+ * ```
+ */
+export declare const crypto_hash_sha256_bytes: PlatformFunctionDef<[typeof BlobType], typeof BlobType>;
+/**
+ * Generates a random UUID v4.
+ *
+ * Creates a version 4 UUID (Universally Unique Identifier) using cryptographically
+ * secure random numbers. UUIDs are 128-bit identifiers formatted as 36-character
+ * strings (e.g., "550e8400-e29b-41d4-a716-446655440000").
+ *
+ * This is a platform function for the East language, enabling UUID generation
+ * in East programs running on Node.js.
+ *
+ * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+ *
+ * @example
+ * ```ts
+ * const createRecord = East.function([], StringType, $ => {
+ *     const id = $.let(Crypto.uuid());
+ *     return id;
+ *     // Returns: "550e8400-e29b-41d4-a716-446655440000"
+ * });
+ * ```
+ */
+export declare const crypto_uuid: PlatformFunctionDef<[], typeof StringType>;
+/**
+ * Node.js implementation of cryptographic platform functions.
+ *
+ * Pass this array to {@link East.compile} to enable crypto operations.
+ */
+declare const CryptoImpl: PlatformFunction[];
+/**
+ * Grouped cryptographic platform functions.
+ *
+ * Provides cryptographic operations for East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, StringType } from "@elaraai/east";
+ * import { Crypto } from "@elaraai/east-node-std";
+ *
+ * const generateId = East.function([], StringType, $ => {
+ *     return Crypto.uuid();
+ * });
+ *
+ * const compiled = East.compile(generateId.toIR(), Crypto.Implementation);
+ * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+ * ```
+ */
+export declare const Crypto: {
+    /**
+     * Generates cryptographically secure random bytes.
+     *
+     * Produces random bytes using a CSPRNG, suitable for generating encryption keys,
+     * tokens, and other security-sensitive random data.
+     *
+     * @param length - The number of random bytes to generate (must be positive)
+     * @returns Random bytes as a Blob (Uint8Array)
+     * @throws {EastError} When random generation fails
+     *
+     * @example
+     * ```ts
+     * const generateToken = East.function([], BlobType, $ => {
+     *     return Crypto.randomBytes(32n);
+     * });
+     *
+     * const compiled = East.compile(generateToken.toIR(), Crypto.Implementation);
+     * compiled();  // Uint8Array(32) [...]
+     * ```
+     */
+    readonly randomBytes: PlatformFunctionDef<[IntegerType], BlobType>;
+    /**
+     * Computes SHA-256 hash of a string.
+     *
+     * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+     * the result as a lowercase hexadecimal string (64 characters).
+     *
+     * @param data - The string to hash (will be UTF-8 encoded)
+     * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+     *
+     * @example
+     * ```ts
+     * const hashPassword = East.function([StringType], StringType, ($, password) => {
+     *     return Crypto.hashSha256(password);
+     * });
+     *
+     * const compiled = East.compile(hashPassword.toIR(), Crypto.Implementation);
+     * compiled("password");  // "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+     * ```
+     */
+    readonly hashSha256: PlatformFunctionDef<[StringType], StringType>;
+    /**
+     * Computes SHA-256 hash of binary data.
+     *
+     * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+     * as raw bytes (32 bytes).
+     *
+     * @param data - The binary data to hash (Blob/Uint8Array)
+     * @returns The SHA-256 hash as binary data (32 bytes)
+     *
+     * @example
+     * ```ts
+     * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+     *     return Crypto.hashSha256Bytes(fileData);
+     * });
+     *
+     * const compiled = East.compile(hashFile.toIR(), Crypto.Implementation);
+     * const fileData = new Uint8Array([1, 2, 3]);
+     * compiled(fileData);  // Uint8Array(32) [...]
+     * ```
+     */
+    readonly hashSha256Bytes: PlatformFunctionDef<[BlobType], BlobType>;
+    /**
+     * Generates a random UUID v4.
+     *
+     * Creates a version 4 UUID using cryptographically secure random numbers.
+     * Returns a 36-character string in standard format.
+     *
+     * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+     *
+     * @example
+     * ```ts
+     * const createRecord = East.function([], StringType, $ => {
+     *     return Crypto.uuid();
+     * });
+     *
+     * const compiled = East.compile(createRecord.toIR(), Crypto.Implementation);
+     * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+     * ```
+     */
+    readonly uuid: PlatformFunctionDef<[], StringType>;
+    /**
+     * Node.js implementation of cryptographic platform functions.
+     *
+     * Pass this to {@link East.compile} to enable crypto operations.
+     */
+    readonly Implementation: PlatformFunction[];
+};
+export { CryptoImpl };
+//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAQ,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAIpF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,OAAO,WAAW,CAAC,EAAE,OAAO,QAAQ,CAAiE,CAAC;AAE7J;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,EAAE,mBAAmB,CAAC,CAAC,OAAO,UAAU,CAAC,EAAE,OAAO,UAAU,CAAiE,CAAC;AAE7J;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,CAAC,OAAO,QAAQ,CAAC,EAAE,OAAO,QAAQ,CAAmE,CAAC;AAEjK;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,WAAW,EAAE,mBAAmB,CAAC,EAAE,EAAE,OAAO,UAAU,CAAgD,CAAC;AAEpH;;;;GAIG;AACH,QAAA,MAAM,UAAU,EAAE,gBAAgB,EAyCjC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM;IACf;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;OAIG;;CAEG,CAAC;AAGX,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/crypto.js

@@ -0,0 +1,259 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { East, StringType, IntegerType, BlobType } from "@elaraai/east";
+import { EastError } from "@elaraai/east/internal";
+import { randomBytes, createHash, randomUUID } from "node:crypto";
+/**
+ * Generates cryptographically secure random bytes.
+ *
+ * Produces random bytes using a cryptographically secure pseudo-random number generator (CSPRNG).
+ * Suitable for generating encryption keys, initialization vectors, tokens, and other security-sensitive
+ * random data.
+ *
+ * This is a platform function for the East language, enabling secure random generation
+ * in East programs running on Node.js.
+ *
+ * @param length - The number of random bytes to generate (must be positive)
+ * @returns Random bytes as a Blob (Uint8Array)
+ *
+ * @throws {EastError} When random generation fails:
+ * - Negative or invalid length
+ * - System entropy pool unavailable
+ *
+ * @example
+ * ```ts
+ * const generateToken = East.function([], BlobType, $ => {
+ *     return Crypto.randomBytes(32n);  // 256-bit token
+ * });
+ * ```
+ */
+export const crypto_random_bytes = East.platform("crypto_random_bytes", [IntegerType], BlobType);
+/**
+ * Computes SHA-256 hash of a string.
+ *
+ * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+ * the result as a lowercase hexadecimal string (64 characters). SHA-256 is a one-way
+ * hash function commonly used for data integrity verification.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running on Node.js.
+ *
+ * @param data - The string to hash (will be UTF-8 encoded)
+ * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+ *
+ * @example
+ * ```ts
+ * const hashPassword = East.function([StringType], StringType, ($, password) => {
+ *     return Crypto.hashSha256(password);
+ *     // Returns: "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+ * });
+ * ```
+ */
+export const crypto_hash_sha256 = East.platform("crypto_hash_sha256", [StringType], StringType);
+/**
+ * Computes SHA-256 hash of binary data.
+ *
+ * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+ * as raw bytes (32 bytes / 256 bits). This is the binary variant of {@link crypto_hash_sha256},
+ * useful when working with binary protocols or when you need the raw hash bytes.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running on Node.js.
+ *
+ * @param data - The binary data to hash (Blob/Uint8Array)
+ * @returns The SHA-256 hash as binary data (32 bytes)
+ *
+ * @example
+ * ```ts
+ * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+ *     return Crypto.hashSha256Bytes(fileData);
+ *     // Returns: 32 bytes of hash data
+ * });
+ * ```
+ */
+export const crypto_hash_sha256_bytes = East.platform("crypto_hash_sha256_bytes", [BlobType], BlobType);
+/**
+ * Generates a random UUID v4.
+ *
+ * Creates a version 4 UUID (Universally Unique Identifier) using cryptographically
+ * secure random numbers. UUIDs are 128-bit identifiers formatted as 36-character
+ * strings (e.g., "550e8400-e29b-41d4-a716-446655440000").
+ *
+ * This is a platform function for the East language, enabling UUID generation
+ * in East programs running on Node.js.
+ *
+ * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+ *
+ * @example
+ * ```ts
+ * const createRecord = East.function([], StringType, $ => {
+ *     const id = $.let(Crypto.uuid());
+ *     return id;
+ *     // Returns: "550e8400-e29b-41d4-a716-446655440000"
+ * });
+ * ```
+ */
+export const crypto_uuid = East.platform("crypto_uuid", [], StringType);
+/**
+ * Node.js implementation of cryptographic platform functions.
+ *
+ * Pass this array to {@link East.compile} to enable crypto operations.
+ */
+const CryptoImpl = [
+    crypto_random_bytes.implement((length) => {
+        try {
+            return randomBytes(Number(length));
+        }
+        catch (err) {
+            throw new EastError(`Failed to generate random bytes: ${err.message}`, {
+                location: { filename: "crypto_random_bytes", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+    crypto_hash_sha256.implement((data) => {
+        try {
+            return createHash('sha256').update(data, 'utf-8').digest('hex');
+        }
+        catch (err) {
+            throw new EastError(`Failed to compute SHA-256 hash: ${err.message}`, {
+                location: { filename: "crypto_hash_sha256", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+    crypto_hash_sha256_bytes.implement((data) => {
+        try {
+            return createHash('sha256').update(data).digest();
+        }
+        catch (err) {
+            throw new EastError(`Failed to compute SHA-256 hash: ${err.message}`, {
+                location: { filename: "crypto_hash_sha256_bytes", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+    crypto_uuid.implement(() => {
+        try {
+            return randomUUID();
+        }
+        catch (err) {
+            throw new EastError(`Failed to generate UUID: ${err.message}`, {
+                location: { filename: "crypto_uuid", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+];
+/**
+ * Grouped cryptographic platform functions.
+ *
+ * Provides cryptographic operations for East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, StringType } from "@elaraai/east";
+ * import { Crypto } from "@elaraai/east-node-std";
+ *
+ * const generateId = East.function([], StringType, $ => {
+ *     return Crypto.uuid();
+ * });
+ *
+ * const compiled = East.compile(generateId.toIR(), Crypto.Implementation);
+ * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+ * ```
+ */
+export const Crypto = {
+    /**
+     * Generates cryptographically secure random bytes.
+     *
+     * Produces random bytes using a CSPRNG, suitable for generating encryption keys,
+     * tokens, and other security-sensitive random data.
+     *
+     * @param length - The number of random bytes to generate (must be positive)
+     * @returns Random bytes as a Blob (Uint8Array)
+     * @throws {EastError} When random generation fails
+     *
+     * @example
+     * ```ts
+     * const generateToken = East.function([], BlobType, $ => {
+     *     return Crypto.randomBytes(32n);
+     * });
+     *
+     * const compiled = East.compile(generateToken.toIR(), Crypto.Implementation);
+     * compiled();  // Uint8Array(32) [...]
+     * ```
+     */
+    randomBytes: crypto_random_bytes,
+    /**
+     * Computes SHA-256 hash of a string.
+     *
+     * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+     * the result as a lowercase hexadecimal string (64 characters).
+     *
+     * @param data - The string to hash (will be UTF-8 encoded)
+     * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+     *
+     * @example
+     * ```ts
+     * const hashPassword = East.function([StringType], StringType, ($, password) => {
+     *     return Crypto.hashSha256(password);
+     * });
+     *
+     * const compiled = East.compile(hashPassword.toIR(), Crypto.Implementation);
+     * compiled("password");  // "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+     * ```
+     */
+    hashSha256: crypto_hash_sha256,
+    /**
+     * Computes SHA-256 hash of binary data.
+     *
+     * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+     * as raw bytes (32 bytes).
+     *
+     * @param data - The binary data to hash (Blob/Uint8Array)
+     * @returns The SHA-256 hash as binary data (32 bytes)
+     *
+     * @example
+     * ```ts
+     * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+     *     return Crypto.hashSha256Bytes(fileData);
+     * });
+     *
+     * const compiled = East.compile(hashFile.toIR(), Crypto.Implementation);
+     * const fileData = new Uint8Array([1, 2, 3]);
+     * compiled(fileData);  // Uint8Array(32) [...]
+     * ```
+     */
+    hashSha256Bytes: crypto_hash_sha256_bytes,
+    /**
+     * Generates a random UUID v4.
+     *
+     * Creates a version 4 UUID using cryptographically secure random numbers.
+     * Returns a 36-character string in standard format.
+     *
+     * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+     *
+     * @example
+     * ```ts
+     * const createRecord = East.function([], StringType, $ => {
+     *     return Crypto.uuid();
+     * });
+     *
+     * const compiled = East.compile(createRecord.toIR(), Crypto.Implementation);
+     * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+     * ```
+     */
+    uuid: crypto_uuid,
+    /**
+     * Node.js implementation of cryptographic platform functions.
+     *
+     * Pass this to {@link East.compile} to enable crypto operations.
+     */
+    Implementation: CryptoImpl,
+};
+// Export for backwards compatibility
+export { CryptoImpl };
+//# sourceMappingURL=crypto.js.map

package/dist/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"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"}