@olakai/sdk
Version:
This document demonstrates how to use the Olakai SDK with all its features.
286 lines • 9.09 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConfigBuilder = exports.DEFAULT_SANITIZE_PATTERNS = void 0;
exports.validateConfig = validateConfig;
exports.getEnvironment = getEnvironment;
exports.createConfig = createConfig;
exports.sanitizeData = sanitizeData;
exports.createErrorInfo = createErrorInfo;
exports.toJsonValue = toJsonValue;
exports.isBrowser = isBrowser;
exports.isNodeJS = isNodeJS;
exports.sleep = sleep;
exports.olakaiLogger = olakaiLogger;
const types_1 = require("./types");
const client_1 = require("./client");
/**
* Default sanitize patterns for sanitizing sensitive data.
* @returns An array of sanitize patterns
*/
exports.DEFAULT_SANITIZE_PATTERNS = [
{ pattern: /\b[\w.-]+@[\w.-]+\.\w+\b/g, replacement: "[REDACTED]" }, // Email addresses
{ pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, replacement: "[REDACTED]" }, // Credit card numbers
{ pattern: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: "[REDACTED]" }, // SSN
{ pattern: /\s*:\s*"[^"]*"/g, key: "password", replacement: "[REDACTED]" }, // Password fields in JSON
{ pattern: /\s*:\s*"[^"]*"/g, key: "token", replacement: "[REDACTED]" }, // Token fields in JSON
{ pattern: /\s*:\s*"[^"]*"/g, key: "apiKey", replacement: "[REDACTED]" }, // API key fields in JSON
{ pattern: /\s*:\s*"[^"]*"/g, key: "secret", replacement: "[REDACTED]" }, // Secret fields in JSON
{ pattern: /\s*:\s*"[^"]*"/g, key: "bearerToken", replacement: "[REDACTED]" }, // Bearer tokens
];
// Validate SDK configuration
function validateConfig(config) {
const errors = [];
if (!config.apiKey || config.apiKey.trim() === "") {
errors.push("API key is required");
}
if (config.monitorEndpoint && !isValidUrl(config.monitorEndpoint)) {
errors.push("API URL must be a valid URL");
}
if (config.batchSize !== undefined &&
(config.batchSize <= 0 || config.batchSize > 1000)) {
errors.push("Batch size must be between 1 and 1000");
}
if (config.batchTime !== undefined && config.batchTime < 0) {
errors.push("Batch time must be non-negative");
}
if (config.retries !== undefined &&
(config.retries < 0 || config.retries > 10)) {
errors.push("Retries must be between 0 and 10");
}
if (config.timeout !== undefined && config.timeout <= 0) {
errors.push("Timeout must be positive");
}
if (config.maxStorageSize !== undefined &&
config.maxStorageSize <= 0) {
errors.push("Max storage size must be positive");
}
return errors;
}
// Check if a string is a valid URL
function isValidUrl(string) {
try {
new URL(string);
return true;
}
catch {
return false;
}
}
// Environment detection
function getEnvironment() {
if (typeof window !== "undefined") {
return "browser";
}
if (typeof process !== "undefined" && process.env) {
return process.env.NODE_ENV || "development";
}
return "unknown";
}
// Create a configuration builder pattern
class ConfigBuilder {
config = {};
apiKey(key) {
this.config.apiKey = key;
return this;
}
monitorEndpoint(url) {
this.config.monitorEndpoint = url;
return this;
}
controlEndpoint(url) {
this.config.controlEndpoint = url;
return this;
}
version(v) {
this.config.version = v;
return this;
}
enableBatching(enable = true) {
this.config.enableBatching = enable;
return this;
}
batchSize(size) {
this.config.batchSize = size;
return this;
}
batchTime(time) {
this.config.batchTime = time;
return this;
}
retries(count) {
this.config.retries = count;
return this;
}
timeout(ms) {
this.config.timeout = ms;
return this;
}
enableStorage(enable = true) {
this.config.enableStorage = enable;
return this;
}
storageKey(key) {
this.config.storageKey = key;
return this;
}
maxStorageSize(size) {
this.config.maxStorageSize = size;
return this;
}
debug(enable = true) {
this.config.debug = enable;
return this;
}
storageType(type = types_1.StorageType.AUTO) {
this.config.storageType = type;
return this;
}
sanitizePatterns(patterns) {
this.config.sanitizePatterns = patterns;
return this;
}
verbose(enable = true) {
this.config.verbose = enable;
return this;
}
build() {
const errors = validateConfig(this.config);
if (errors.length > 0) {
throw new Error(`Configuration validation failed: ${errors.join(", ")}`);
}
return {
apiKey: "",
monitorEndpoint: "",
controlEndpoint: "",
enableBatching: true,
batchSize: 10,
batchTime: 5000,
retries: 3,
timeout: 10000,
enableStorage: true,
storageKey: "olakai-sdk-queue",
maxStorageSize: 1000000,
sanitizePatterns: exports.DEFAULT_SANITIZE_PATTERNS,
debug: false,
verbose: false,
...this.config,
};
}
}
exports.ConfigBuilder = ConfigBuilder;
// Factory function for the builder
function createConfig() {
return new ConfigBuilder();
}
/**
* Sanitize data by replacing sensitive information with a custom placeholder
* @param data - The data to sanitize
* @param patterns - The patterns to replace
* @returns The sanitized data
*/
function sanitizeData(data, dataKey, patterns) {
if (!patterns?.length)
return data;
let serialized = data;
patterns.forEach((pattern) => {
if (pattern.pattern) {
return serialized.replace(pattern.pattern, pattern.replacement || "[REDACTED]");
}
else if (pattern.key) {
if (dataKey && dataKey.includes(pattern.key)) {
return pattern.replacement || "[REDACTED]";
}
else {
return data;
}
}
});
try {
olakaiLogger(`Data successfully sanitized`, "info");
return serialized;
}
catch {
olakaiLogger(`Data failed to sanitize`, "warn");
return "[SANITIZED]";
}
}
function createErrorInfo(error) {
return {
errorMessage: error instanceof Error ? error.message : String(error),
stackTrace: error instanceof Error ? error.stack : undefined,
};
}
function toJsonValue(val, sanitize = false) {
try {
// Handle null and undefined
if (val === null || val === undefined)
return null;
// Handle primitives that are already JsonValue
if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
if (sanitize) {
return sanitizeData(String(val), undefined, (0, client_1.getConfig)().sanitizePatterns);
}
return val;
}
// Handle arrays
if (Array.isArray(val)) {
return val.map(item => toJsonValue(item, sanitize));
}
// Handle objects
if (val && typeof val === "object") {
const result = {};
for (const [key, value] of Object.entries(val)) {
if (sanitize) {
result[key] = sanitizeData(String(value), key, (0, client_1.getConfig)().sanitizePatterns);
}
else {
result[key] = toJsonValue(value, sanitize);
}
}
return result;
}
// Fallback for other types - convert to string
return String(val);
}
catch (error) {
olakaiLogger(`Error converting value to JsonValue: ${error}`, "error");
return String(val);
}
}
/**
* Environment detection utilities
*/
function isBrowser() {
return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
}
function isNodeJS() {
return typeof process !== 'undefined' && process.versions && process.versions.node !== 'false';
}
/**
* Sleep for a given number of milliseconds
* @param ms - The number of milliseconds to sleep
* @returns A promise that resolves after the given number of milliseconds
*/
async function sleep(ms) {
olakaiLogger(`Sleeping for ${ms}ms`, "info");
return new Promise((resolve) => setTimeout(resolve, ms));
}
function olakaiLogger(message, level = "info") {
const config = (0, client_1.getConfig)();
switch (level) {
case "info":
if (config.verbose) {
console.log(`[Olakai SDK] ${message}`);
}
break;
case "warn":
console.warn(`[Olakai SDK] ${message}`);
break;
case "error":
if (config.debug) {
console.error(`[Olakai SDK] ${message}`);
}
break;
}
}
//# sourceMappingURL=utils.js.map