@cardql/node
Version:
CardQL SDK for Node.js and serverless applications
339 lines (331 loc) • 9.21 kB
JavaScript
;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
CardQL: () => NodeCardQL,
Logger: () => Logger,
NodeCardQL: () => NodeCardQL,
NodeCardQLClient: () => NodeCardQLClient,
cardqlErrorHandler: () => cardqlErrorHandler,
cardqlMiddleware: () => cardqlMiddleware,
createCardQLContext: () => createCardQLContext,
createConfigFromEnv: () => createConfigFromEnv,
default: () => index_default,
defaultLogger: () => defaultLogger,
environmentConfigs: () => environmentConfigs,
validateConfig: () => validateConfig,
withCardQL: () => withCardQL
});
module.exports = __toCommonJS(index_exports);
__reExport(index_exports, require("@cardql/core"), module.exports);
// src/client.ts
var import_core = require("@cardql/core");
// src/config.ts
function createConfigFromEnv(overrides = {}) {
const config = {
apiKey: overrides.apiKey || process.env.CARDQL_API_KEY || "",
endpoint: overrides.endpoint || process.env.CARDQL_ENDPOINT || "https://api.cardql.com/graphql",
timeout: overrides.timeout || parseInt(process.env.CARDQL_TIMEOUT || "30000"),
retries: overrides.retries || parseInt(process.env.CARDQL_RETRIES || "3")
};
if (!config.apiKey) {
throw new Error(
"CardQL API key is required. Set CARDQL_API_KEY environment variable or provide apiKey in config."
);
}
if (!config.endpoint) {
throw new Error(
"CardQL endpoint is required. Set CARDQL_ENDPOINT environment variable or provide endpoint in config."
);
}
return config;
}
function validateConfig(config) {
if (!config.apiKey?.trim()) {
throw new Error("CardQL API key cannot be empty");
}
if (!config.endpoint?.trim()) {
throw new Error("CardQL endpoint cannot be empty");
}
try {
new URL(config.endpoint);
} catch {
throw new Error("CardQL endpoint must be a valid URL");
}
if (config.timeout && (config.timeout < 1e3 || config.timeout > 3e5)) {
throw new Error(
"CardQL timeout must be between 1000ms and 300000ms (5 minutes)"
);
}
if (config.retries && (config.retries < 0 || config.retries > 10)) {
throw new Error("CardQL retries must be between 0 and 10");
}
}
var environmentConfigs = {
development: {
timeout: 3e4,
retries: 3,
enableLogging: true,
logLevel: "debug"
},
staging: {
timeout: 3e4,
retries: 3,
enableLogging: true,
logLevel: "info"
},
production: {
timeout: 15e3,
retries: 2,
enableLogging: false,
logLevel: "error"
}
};
// src/logger.ts
var Logger = class {
enabled;
level;
constructor(enabled = false, level = "info") {
this.enabled = enabled;
this.level = level;
}
shouldLog(level) {
if (!this.enabled) return false;
const levels = {
error: 0,
warn: 1,
info: 2,
debug: 3
};
return levels[level] <= levels[this.level];
}
formatMessage(level, message, metadata) {
const timestamp = (/* @__PURE__ */ new Date()).toISOString();
const prefix = `[${timestamp}] [${level.toUpperCase()}] [CardQL]`;
if (metadata) {
return `${prefix} ${message} ${JSON.stringify(metadata)}`;
}
return `${prefix} ${message}`;
}
error(message, metadata) {
if (this.shouldLog("error")) {
console.error(this.formatMessage("error", message, metadata));
}
}
warn(message, metadata) {
if (this.shouldLog("warn")) {
console.warn(this.formatMessage("warn", message, metadata));
}
}
info(message, metadata) {
if (this.shouldLog("info")) {
console.info(this.formatMessage("info", message, metadata));
}
}
debug(message, metadata) {
if (this.shouldLog("debug")) {
console.debug(this.formatMessage("debug", message, metadata));
}
}
setEnabled(enabled) {
this.enabled = enabled;
}
setLevel(level) {
this.level = level;
}
};
var defaultLogger = new Logger();
// src/client.ts
var NodeCardQLClient = class extends import_core.CardQLClient {
logger;
constructor(config, logger) {
super(config);
this.logger = logger || defaultLogger;
}
async request(query, variables) {
this.logger.debug("Making GraphQL request", {
query: query.substring(0, 100) + "...",
variables
});
try {
const result = await super.request(query, variables);
this.logger.debug("GraphQL request successful");
return result;
} catch (error) {
this.logger.error("GraphQL request failed", {
error: error.message,
code: error.code
});
throw error;
}
}
};
var NodeCardQL = class _NodeCardQL extends import_core.CardQL {
client;
api;
logger;
constructor(config) {
const finalConfig = config ? {
...createConfigFromEnv(),
...config
} : createConfigFromEnv();
validateConfig(finalConfig);
const logger = new Logger(
config?.enableLogging ?? false,
config?.logLevel ?? "info"
);
const nodeClient = new NodeCardQLClient(finalConfig, logger);
super(finalConfig);
this.client = nodeClient;
this.api = new import_core.CardQLApi(this.client);
this.logger = logger;
this.logger.info("CardQL Node.js client initialized", {
endpoint: finalConfig.endpoint,
timeout: finalConfig.timeout,
retries: finalConfig.retries
});
}
/**
* Create instance with environment-specific defaults
*/
static forEnvironment(env, overrides = {}) {
const envConfig = environmentConfigs[env];
return new _NodeCardQL({
...envConfig,
...overrides,
env
});
}
/**
* Enable or disable logging
*/
setLogging(enabled, level) {
this.logger.setEnabled(enabled);
if (level) {
this.logger.setLevel(level);
}
}
/**
* Health check method to verify connectivity
*/
async healthCheck() {
try {
this.logger.info("Performing health check...");
await this.api.getAccounts();
this.logger.info("Health check passed");
return true;
} catch (error) {
this.logger.error("Health check failed", { error: error.message });
return false;
}
}
/**
* Get client statistics
*/
getStats() {
return {
endpoint: this.client["config"].endpoint,
timeout: this.client["config"].timeout || 3e4,
retries: this.client["config"].retries || 3,
loggingEnabled: this.logger["enabled"]
};
}
};
// src/middleware.ts
function cardqlMiddleware(options = {}) {
const cardql = new NodeCardQL(options);
if (!options.skipHealthCheck) {
cardql.healthCheck().catch((error) => {
console.warn("[CardQL] Initial health check failed:", error.message);
});
}
return (req, res, next) => {
req.cardql = cardql;
next();
};
}
function cardqlErrorHandler() {
return (error, req, res, next) => {
if (error.code && error.message) {
const statusCode = getHttpStatusFromCardQLError(error);
res.status(statusCode).json({
error: {
message: error.message,
code: error.code,
details: error.details
}
});
return;
}
next(error);
};
}
function getHttpStatusFromCardQLError(error) {
switch (error.code) {
case "UNAUTHENTICATED":
case "INVALID_API_KEY":
return 401;
case "FORBIDDEN":
case "INSUFFICIENT_PERMISSIONS":
return 403;
case "NOT_FOUND":
case "RESOURCE_NOT_FOUND":
return 404;
case "VALIDATION_ERROR":
case "INVALID_INPUT":
return 400;
case "RATE_LIMITED":
return 429;
case "HTTP_ERROR":
return error.details?.status || 500;
default:
return 500;
}
}
function createCardQLContext(config) {
return {
cardql: new NodeCardQL(config)
};
}
function withCardQL(handler, config) {
const cardql = new NodeCardQL(config);
return async (event, context) => {
return handler(event, { ...context, cardql });
};
}
// src/index.ts
var index_default = NodeCardQL;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
CardQL,
Logger,
NodeCardQL,
NodeCardQLClient,
cardqlErrorHandler,
cardqlMiddleware,
createCardQLContext,
createConfigFromEnv,
defaultLogger,
environmentConfigs,
validateConfig,
withCardQL,
...require("@cardql/core")
});