@sisense/mcp-server 0.2.1

package/dist/index-g8bgq79c.js

@@ -0,0 +1,53 @@
+import {
+  require_client
+} from "./sse-server-mkesh468.js";
+import {
+  require_dist_cjs
+} from "./sse-server-3343e7xh.js";
+import {
+  __commonJS
+} from "./sse-server-7wcvyxyj.js";
+
+// node_modules/@aws-sdk/credential-provider-env/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var client = require_client();
+  var propertyProvider = require_dist_cjs();
+  var ENV_KEY = "AWS_ACCESS_KEY_ID";
+  var ENV_SECRET = "AWS_SECRET_ACCESS_KEY";
+  var ENV_SESSION = "AWS_SESSION_TOKEN";
+  var ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION";
+  var ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE";
+  var ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID";
+  var fromEnv = (init) => async () => {
+    init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
+    const accessKeyId = process.env[ENV_KEY];
+    const secretAccessKey = process.env[ENV_SECRET];
+    const sessionToken = process.env[ENV_SESSION];
+    const expiry = process.env[ENV_EXPIRATION];
+    const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
+    const accountId = process.env[ENV_ACCOUNT_ID];
+    if (accessKeyId && secretAccessKey) {
+      const credentials = {
+        accessKeyId,
+        secretAccessKey,
+        ...sessionToken && { sessionToken },
+        ...expiry && { expiration: new Date(expiry) },
+        ...credentialScope && { credentialScope },
+        ...accountId && { accountId }
+      };
+      client.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g");
+      return credentials;
+    }
+    throw new propertyProvider.CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger });
+  };
+  exports.ENV_ACCOUNT_ID = ENV_ACCOUNT_ID;
+  exports.ENV_CREDENTIAL_SCOPE = ENV_CREDENTIAL_SCOPE;
+  exports.ENV_EXPIRATION = ENV_EXPIRATION;
+  exports.ENV_KEY = ENV_KEY;
+  exports.ENV_SECRET = ENV_SECRET;
+  exports.ENV_SESSION = ENV_SESSION;
+  exports.fromEnv = fromEnv;
+});
+export default require_dist_cjs2();
+
+export { require_dist_cjs2 as require_dist_cjs };

package/dist/index-p1pxtmwn.js

@@ -0,0 +1,162 @@
+import {
+  require_sts
+} from "./index-er0yspcy.js";
+import"./sse-server-4b60tg0c.js";
+import"./sse-server-4jjec4fz.js";
+import"./sse-server-nwjjjz6x.js";
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./sse-server-qj4zxq0f.js";
+import"./sse-server-txz5g5t0.js";
+import"./sse-server-epd916s3.js";
+import"./sse-server-5tmgacdx.js";
+import"./sse-server-4g9za0qq.js";
+import {
+  require_client
+} from "./sse-server-mkesh468.js";
+import {
+  require_dist_cjs
+} from "./sse-server-3343e7xh.js";
+import {
+  __commonJS,
+  __require
+} from "./sse-server-7wcvyxyj.js";
+
+// node_modules/@aws-sdk/credential-provider-web-identity/dist-cjs/fromWebToken.js
+var require_fromWebToken = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k = ownKeys(mod), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod, k[i]);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  }();
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromWebToken = undefined;
+  var fromWebToken = (init) => async (awsIdentityProperties) => {
+    init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
+    const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
+    let { roleAssumerWithWebIdentity } = init;
+    if (!roleAssumerWithWebIdentity) {
+      const { getDefaultRoleAssumerWithWebIdentity } = await Promise.resolve().then(() => __importStar(require_sts()));
+      roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
+        ...init.clientConfig,
+        credentialProviderLogger: init.logger,
+        parentClientConfig: {
+          ...awsIdentityProperties?.callerClientConfig,
+          ...init.parentClientConfig
+        }
+      }, init.clientPlugins);
+    }
+    return roleAssumerWithWebIdentity({
+      RoleArn: roleArn,
+      RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
+      WebIdentityToken: webIdentityToken,
+      ProviderId: providerId,
+      PolicyArns: policyArns,
+      Policy: policy,
+      DurationSeconds: durationSeconds
+    });
+  };
+  exports.fromWebToken = fromWebToken;
+});
+
+// node_modules/@aws-sdk/credential-provider-web-identity/dist-cjs/fromTokenFile.js
+var require_fromTokenFile = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromTokenFile = undefined;
+  var client_1 = require_client();
+  var property_provider_1 = require_dist_cjs();
+  var shared_ini_file_loader_1 = require_dist_cjs2();
+  var fs_1 = __require("fs");
+  var fromWebToken_1 = require_fromWebToken();
+  var ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE";
+  var ENV_ROLE_ARN = "AWS_ROLE_ARN";
+  var ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME";
+  var fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
+    init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
+    const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
+    const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
+    const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
+    if (!webIdentityTokenFile || !roleArn) {
+      throw new property_provider_1.CredentialsProviderError("Web identity configuration not specified", {
+        logger: init.logger
+      });
+    }
+    const credentials = await (0, fromWebToken_1.fromWebToken)({
+      ...init,
+      webIdentityToken: shared_ini_file_loader_1.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? (0, fs_1.readFileSync)(webIdentityTokenFile, { encoding: "ascii" }),
+      roleArn,
+      roleSessionName
+    })(awsIdentityProperties);
+    if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
+      (0, client_1.setCredentialFeature)(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
+    }
+    return credentials;
+  };
+  exports.fromTokenFile = fromTokenFile;
+});
+
+// node_modules/@aws-sdk/credential-provider-web-identity/dist-cjs/index.js
+var require_dist_cjs3 = __commonJS((exports) => {
+  var fromTokenFile = require_fromTokenFile();
+  var fromWebToken = require_fromWebToken();
+  Object.keys(fromTokenFile).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function() {
+          return fromTokenFile[k];
+        }
+      });
+  });
+  Object.keys(fromWebToken).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function() {
+          return fromWebToken[k];
+        }
+      });
+  });
+});
+export default require_dist_cjs3();
+
+export { require_dist_cjs3 as require_dist_cjs };

package/dist/index-qdth51hx.js

@@ -0,0 +1,250 @@
+import {
+  require_dist_cjs2 as require_dist_cjs
+} from "./sse-server-5tmgacdx.js";
+import {
+  __esm
+} from "./sse-server-7wcvyxyj.js";
+
+// node_modules/@smithy/core/dist-cjs/submodules/event-streams/index.js
+class EventStreamSerde {
+  marshaller;
+  serializer;
+  deserializer;
+  serdeContext;
+  defaultContentType;
+  constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType }) {
+    this.marshaller = marshaller;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.serdeContext = serdeContext;
+    this.defaultContentType = defaultContentType;
+  }
+  async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = requestSchema.getEventStreamMember();
+    const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+    const serializer = this.serializer;
+    const defaultContentType = this.defaultContentType;
+    const initialRequestMarker = Symbol("initialRequestMarker");
+    const eventStreamIterable = {
+      async* [Symbol.asyncIterator]() {
+        if (initialRequest) {
+          const headers = {
+            ":event-type": { type: "string", value: "initial-request" },
+            ":message-type": { type: "string", value: "event" },
+            ":content-type": { type: "string", value: defaultContentType }
+          };
+          serializer.write(requestSchema, initialRequest);
+          const body = serializer.flush();
+          yield {
+            [initialRequestMarker]: true,
+            headers,
+            body
+          };
+        }
+        for await (const page of eventStream) {
+          yield page;
+        }
+      }
+    };
+    return marshaller.serialize(eventStreamIterable, (event) => {
+      if (event[initialRequestMarker]) {
+        return {
+          headers: event.headers,
+          body: event.body
+        };
+      }
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+      const headers = {
+        ":event-type": { type: "string", value: eventType },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+        ...additionalHeaders
+      };
+      return {
+        headers,
+        body
+      };
+    });
+  }
+  async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
+    const marshaller = this.marshaller;
+    const eventStreamMember = responseSchema.getEventStreamMember();
+    const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+    const memberSchemas = unionSchema.getMemberSchemas();
+    const initialResponseMarker = Symbol("initialResponseMarker");
+    const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+      const unionMember = Object.keys(event).find((key) => {
+        return key !== "__type";
+      }) ?? "";
+      const body = event[unionMember].body;
+      if (unionMember === "initial-response") {
+        const dataObject = await this.deserializer.read(responseSchema, body);
+        delete dataObject[eventStreamMember];
+        return {
+          [initialResponseMarker]: true,
+          ...dataObject
+        };
+      } else if (unionMember in memberSchemas) {
+        const eventStreamSchema = memberSchemas[unionMember];
+        if (eventStreamSchema.isStructSchema()) {
+          const out = {};
+          let hasBindings = false;
+          for (const [name, member] of eventStreamSchema.structIterator()) {
+            const { eventHeader, eventPayload } = member.getMergedTraits();
+            hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
+            if (eventPayload) {
+              if (member.isBlobSchema()) {
+                out[name] = body;
+              } else if (member.isStringSchema()) {
+                out[name] = (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)(body);
+              } else if (member.isStructSchema()) {
+                out[name] = await this.deserializer.read(member, body);
+              }
+            } else if (eventHeader) {
+              const value = event[unionMember].headers[name]?.value;
+              if (value != null) {
+                if (member.isNumericSchema()) {
+                  if (value && typeof value === "object" && "bytes" in value) {
+                    out[name] = BigInt(value.toString());
+                  } else {
+                    out[name] = Number(value);
+                  }
+                } else {
+                  out[name] = value;
+                }
+              }
+            }
+          }
+          if (hasBindings) {
+            return {
+              [unionMember]: out
+            };
+          }
+        }
+        return {
+          [unionMember]: await this.deserializer.read(eventStreamSchema, body)
+        };
+      } else {
+        return {
+          $unknown: event
+        };
+      }
+    });
+    const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+    const firstEvent = await asyncIterator.next();
+    if (firstEvent.done) {
+      return asyncIterable;
+    }
+    if (firstEvent.value?.[initialResponseMarker]) {
+      if (!responseSchema) {
+        throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+      }
+      for (const [key, value] of Object.entries(firstEvent.value)) {
+        initialResponseContainer[key] = value;
+      }
+    }
+    return {
+      async* [Symbol.asyncIterator]() {
+        if (!firstEvent?.value?.[initialResponseMarker]) {
+          yield firstEvent.value;
+        }
+        while (true) {
+          const { done, value } = await asyncIterator.next();
+          if (done) {
+            break;
+          }
+          yield value;
+        }
+      }
+    };
+  }
+  writeEventBody(unionMember, unionSchema, event) {
+    const serializer = this.serializer;
+    let eventType = unionMember;
+    let explicitPayloadMember = null;
+    let explicitPayloadContentType;
+    const isKnownSchema = (() => {
+      const struct = unionSchema.getSchema();
+      return struct[4].includes(unionMember);
+    })();
+    const additionalHeaders = {};
+    if (!isKnownSchema) {
+      const [type, value] = event[unionMember];
+      eventType = type;
+      serializer.write(15, value);
+    } else {
+      const eventSchema = unionSchema.getMemberSchema(unionMember);
+      if (eventSchema.isStructSchema()) {
+        for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+          const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+          if (eventPayload) {
+            explicitPayloadMember = memberName;
+          } else if (eventHeader) {
+            const value = event[unionMember][memberName];
+            let type = "binary";
+            if (memberSchema.isNumericSchema()) {
+              if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                type = "integer";
+              } else {
+                type = "long";
+              }
+            } else if (memberSchema.isTimestampSchema()) {
+              type = "timestamp";
+            } else if (memberSchema.isStringSchema()) {
+              type = "string";
+            } else if (memberSchema.isBooleanSchema()) {
+              type = "boolean";
+            }
+            if (value != null) {
+              additionalHeaders[memberName] = {
+                type,
+                value
+              };
+              delete event[unionMember][memberName];
+            }
+          }
+        }
+        if (explicitPayloadMember !== null) {
+          const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+          if (payloadSchema.isBlobSchema()) {
+            explicitPayloadContentType = "application/octet-stream";
+          } else if (payloadSchema.isStringSchema()) {
+            explicitPayloadContentType = "text/plain";
+          }
+          serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+        } else {
+          serializer.write(eventSchema, event[unionMember]);
+        }
+      } else {
+        throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+      }
+    }
+    const messageSerialization = serializer.flush();
+    const body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? utilUtf8.fromUtf8)(messageSerialization) : messageSerialization;
+    return {
+      body,
+      eventType,
+      explicitPayloadContentType,
+      additionalHeaders
+    };
+  }
+}
+var utilUtf8, $EventStreamSerde;
+var init_event_streams = __esm(() => {
+  utilUtf8 = require_dist_cjs();
+  $EventStreamSerde = EventStreamSerde;
+});
+init_event_streams();
+
+export {
+  $EventStreamSerde as EventStreamSerde
+};
+export default {
+  get EventStreamSerde() {
+    return $EventStreamSerde;
+  }
+};