@squidcloud/local-backend 1.0.25 → 1.0.27

package/dist/common/src/integrations/api.types.d.ts

@@ -0,0 +1,80 @@
+import { FieldName } from '../document.types';
+import { IntrospectionQuery } from '../graphql.types';
+import { BaseIntegrationConfig, IntegrationType } from './index';
+export type HttpMethod = 'post' | 'get' | 'delete' | 'patch' | 'put';
+export type ApiEndpointId = string;
+export type ApiParameterLocation = 'query' | 'body' | 'header' | 'path';
+export type ApiResponseParameterLocation = 'header' | 'body';
+export type ApiInjectionParameterLocation = 'header' | 'query';
+export type FieldPath = string;
+export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
+export interface IntegrationGraphQLSchema {
+    introspection: IntrospectionQuery;
+}
+export interface IntegrationApiSchema {
+    baseUrl: string;
+    endpoints: IntegrationApiEndpoints;
+    injectionSchema?: ApiInjectionSchema;
+}
+export interface ApiRequestField {
+    location: ApiParameterLocation;
+}
+export interface ApiResponseField {
+    location: ApiResponseParameterLocation;
+    path?: FieldPath;
+}
+export type ApiInjectionFieldType = 'secret' | 'regular';
+export interface ApiInjectionField {
+    value: string;
+    type: ApiInjectionFieldType;
+    location: ApiInjectionParameterLocation;
+}
+export interface GraphQLConnectionOptions {
+    baseUrl: string;
+    injectionSchema?: ApiInjectionSchema;
+}
+export type ApiInjectionSchema = Record<FieldName, ApiInjectionField>;
+export interface OpenApiDiscoveryOptions {
+    openApiSpecUrl: string;
+}
+export interface ApiEndpoint {
+    relativePath: string;
+    method: HttpMethod;
+    requestSchema?: Record<FieldName, ApiRequestField>;
+    responseSchema?: Record<FieldPath, ApiResponseField>;
+    injectionSchema?: ApiInjectionSchema;
+}
+export interface HttpApiIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.api;
+    configuration?: {
+        discoveryOptions: OpenApiDiscoveryOptions;
+    };
+    schema: IntegrationApiSchema;
+}
+export interface GraphQLIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.graphql;
+    schema?: IntegrationGraphQLSchema;
+    configuration: {
+        connectionOptions: GraphQLConnectionOptions;
+    };
+}
+export interface DiscoverGraphQLConnectionSchemaRequest {
+    integrationType: IntegrationType.graphql;
+    connectionOptions: GraphQLConnectionOptions;
+}
+export interface DiscoverOpenApiSchemaRequest {
+    integrationType: IntegrationType.api;
+    discoveryOptions: OpenApiDiscoveryOptions;
+}
+export interface TestGraphQLDataConnectionRequest {
+    type: IntegrationType.graphql;
+    configuration: {
+        connectionOptions: GraphQLConnectionOptions;
+    };
+}
+export interface DiscoverGraphQLConnectionSchemaResponse {
+    schema: IntegrationGraphQLSchema;
+}
+export interface DiscoverOpenApiSchemaResponse {
+    schema: IntegrationApiSchema;
+}

package/dist/common/src/integrations/api.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.types.js.map

package/dist/common/src/integrations/api.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.types.js","sourceRoot":"","sources":["../../../../../common/src/integrations/api.types.ts"],"names":[],"mappings":""}

package/dist/common/src/integrations/auth.types.d.ts

@@ -0,0 +1,22 @@
+import { Validations } from '../auth.types';
+import { BaseIntegrationConfig, IntegrationType } from './index';
+export interface Auth0IntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.auth0;
+    configuration: {
+        clientId: string;
+        domain: string;
+    };
+}
+export interface JwtRsaIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.jwt_rsa;
+    configuration: {
+        jwksUri: string;
+        validations?: Validations;
+    };
+}
+export interface JwtHmacIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.jwt_hmac;
+    configuration: {
+        verifyUri?: string;
+    };
+}

package/dist/common/src/integrations/auth.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=auth.types.js.map

package/dist/common/src/integrations/auth.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.types.js","sourceRoot":"","sources":["../../../../../common/src/integrations/auth.types.ts"],"names":[],"mappings":""}

package/dist/common/src/integrations/database.types.d.ts

@@ -0,0 +1,236 @@
+import { CollectionName } from '../document.types';
+import { CollectionSchema } from '../schema/schema.types';
+import { BaseIntegrationConfig, DatabaseIntegrationType, IntegrationType } from './index';
+export interface MongoConnectionSecretOptions {
+    password?: string;
+}
+export interface MongoConnectionOptions {
+    secrets: MongoConnectionSecretOptions;
+    connectionString: string;
+    user?: string;
+    replicaSet?: string;
+    ssl?: {
+        certificateFile: string;
+        validate: boolean;
+    };
+    maxPoolSize?: number;
+    minPoolSize?: number;
+    socketTimeoutMS?: number;
+    serverSelectionTimeoutMS?: number;
+    keepAlive?: boolean;
+    directConnection?: boolean;
+}
+export interface MySqlConnectionSecretOptions {
+    password: string;
+}
+export interface OracleConnectionSecretOptions {
+    password: string;
+}
+export interface MssqlConnectionSecretOptions {
+    password: string;
+}
+export interface PostgresConnectionSecretOptions {
+    password: string;
+    sslCertificate?: string;
+}
+export interface MySqlConnectionOptions {
+    secrets: MySqlConnectionSecretOptions;
+    host: string;
+    user: string;
+    database: string;
+    connectionLimit?: number;
+    sslEnabled?: boolean;
+}
+export interface OracleConnectionOptions {
+    secrets: OracleConnectionSecretOptions;
+    host: string;
+    user: string;
+    database: string;
+    connectionLimit?: number;
+}
+export interface MssqlConnectionOptions {
+    secrets: MssqlConnectionSecretOptions;
+    host: string;
+    user: string;
+    schema: string;
+    database: string;
+    connectionLimit?: number;
+    sslEnabled?: boolean;
+}
+export interface PostgresConnectionOptions {
+    host: string;
+    user: string;
+    database: string;
+    schema?: string;
+    sslEnabled?: boolean;
+    secrets: PostgresConnectionSecretOptions;
+}
+export interface SnowflakeConnectionSecretOptions {
+    password: string;
+}
+export interface SnowflakeConnectionOptions {
+    secrets: SnowflakeConnectionSecretOptions;
+    account: string;
+    username: string;
+    database: string;
+    schema: string;
+    warehouse: string;
+    role: string;
+}
+type TableName = string;
+export interface IntegrationDataSchema {
+    collections: Record<TableName, CollectionSchema>;
+}
+export interface BaseDatabaseIntegrationConfig extends BaseIntegrationConfig {
+    type: DatabaseIntegrationType;
+    schema?: IntegrationDataSchema;
+    supportsExternalChanges: boolean;
+}
+export interface MySqlIntegrationConfiguration {
+    connectionOptions: MySqlConnectionOptions;
+}
+export interface OracleIntegrationConfiguration {
+    connectionOptions: OracleConnectionOptions;
+}
+export interface MssqlIntegrationConfiguration {
+    connectionOptions: MssqlConnectionOptions;
+}
+export interface PostgresIntegrationConfiguration {
+    connectionOptions: PostgresConnectionOptions;
+}
+export interface MongoIntegrationConfiguration {
+    connectionOptions: MongoConnectionOptions;
+}
+export interface SnowflakeIntegrationConfiguration {
+    connectionOptions: SnowflakeConnectionOptions;
+}
+export interface MySqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.mysql;
+    configuration: MySqlIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+}
+export interface OracleIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.oracledb;
+    configuration: OracleIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+}
+export interface MssqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.mssql;
+    configuration: MssqlIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+}
+export interface BasePostgresIntegration extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.postgres | IntegrationType.cockroach;
+    configuration: PostgresIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+}
+export interface PostgresIntegrationConfig extends BasePostgresIntegration {
+    type: IntegrationType.postgres;
+}
+export interface CockroachIntegrationConfig extends BasePostgresIntegration {
+    type: IntegrationType.cockroach;
+    supportsExternalChanges: false;
+}
+export interface InternalIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.built_in_db;
+}
+export interface MongoIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.mongo;
+    configuration: MongoIntegrationConfiguration;
+}
+export interface SnowflakeIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.snowflake;
+    configuration: SnowflakeIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+    supportsExternalChanges: false;
+}
+interface TestMongoDataConnectionRequest {
+    type: IntegrationType.mongo;
+    configuration: {
+        connectionOptions: MongoConnectionOptions;
+    };
+}
+interface TestMysqlDataConnectionRequest {
+    type: IntegrationType.mysql;
+    configuration: {
+        connectionOptions: MySqlConnectionOptions;
+    };
+}
+interface TestOracleDataConnectionRequest {
+    type: IntegrationType.oracledb;
+    configuration: {
+        connectionOptions: OracleConnectionOptions;
+    };
+}
+interface TestMssqlDataConnectionRequest {
+    type: IntegrationType.mssql;
+    configuration: {
+        connectionOptions: MssqlConnectionOptions;
+    };
+}
+interface TestPostgresDataConnectionRequest {
+    type: IntegrationType.postgres;
+    configuration: {
+        connectionOptions: PostgresConnectionOptions;
+    };
+}
+interface TestSnowflakeDataConnectionRequest {
+    type: IntegrationType.snowflake;
+    configuration: {
+        connectionOptions: SnowflakeConnectionOptions;
+    };
+}
+interface TestCockroachDataConnectionRequest {
+    type: IntegrationType.cockroach;
+    configuration: {
+        connectionOptions: PostgresConnectionOptions;
+    };
+}
+export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestOracleDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest | TestSnowflakeDataConnectionRequest;
+export interface CollectionReadiness {
+    hasPermissions: boolean;
+    grantPermissionsCommands: string[];
+    replicationEnabled: boolean;
+    enableReplicationCommands: string[];
+}
+export interface DiscoverDataConnectionSchemaResponse {
+    schema: IntegrationDataSchema;
+    collectionReadiness: Record<CollectionName, CollectionReadiness>;
+}
+interface DiscoverMongoDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mongo;
+    connectionOptions: MongoConnectionOptions;
+}
+interface DiscoverInternalDataConnectionSchemaRequest {
+    integrationType: IntegrationType.built_in_db;
+}
+interface DiscoverMysqlDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mysql;
+    connectionOptions: MySqlConnectionOptions;
+}
+interface DiscoverOracleDataConnectionSchemaRequest {
+    integrationType: IntegrationType.oracledb;
+    connectionOptions: OracleConnectionOptions;
+}
+interface DiscoverMssqlDataConnectionSchemaRequest {
+    integrationType: IntegrationType.mssql;
+    connectionOptions: MssqlConnectionOptions;
+}
+interface DiscoverPostgresDataConnectionSchemaRequest {
+    integrationType: IntegrationType.postgres;
+    connectionOptions: PostgresConnectionOptions;
+}
+interface DiscoverSnowflakeDataConnectionSchemaRequest {
+    integrationType: IntegrationType.snowflake;
+    connectionOptions: SnowflakeConnectionOptions;
+}
+interface DiscoverCockroachDataConnectionSchemaRequest {
+    integrationType: IntegrationType.cockroach;
+    connectionOptions: PostgresConnectionOptions;
+}
+export interface TestDataConnectionResponse {
+    success: boolean;
+    errorMessage?: string;
+}
+export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverOracleDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest | DiscoverSnowflakeDataConnectionSchemaRequest;
+export {};

package/dist/common/src/integrations/database.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=database.types.js.map

package/dist/common/src/integrations/database.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.types.js","sourceRoot":"","sources":["../../../../../common/src/integrations/database.types.ts"],"names":[],"mappings":""}

package/dist/common/src/integrations/index.d.ts

@@ -0,0 +1,97 @@
+export * from './ai_assistant.types';
+export * from './api.types';
+export * from './auth.types';
+export * from './database.types';
+export * from './observability.types';
+import { IntegrationId } from '../communication.types';
+import { AiAssistantIntegrationConfig } from './ai_assistant.types';
+import { GraphQLIntegrationConfig, HttpApiIntegrationConfig, TestGraphQLDataConnectionRequest } from './api.types';
+import { Auth0IntegrationConfig, JwtHmacIntegrationConfig, JwtRsaIntegrationConfig } from './auth.types';
+import { BaseDatabaseIntegrationConfig, CockroachIntegrationConfig, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig, TestDataConnectionRequest } from './database.types';
+import { DatadogIntegrationConfig, NewRelicIntegrationConfig } from './observability.types';
+export declare enum IntegrationCategory {
+    'database' = "database",
+    'api' = "api",
+    'observability' = "observability",
+    'crm' = "crm",
+    'auth' = "auth",
+    'ai' = "ai"
+}
+export declare enum IntegrationType {
+    'built_in_db' = "built_in_db",
+    'mongo' = "mongo",
+    'mysql' = "mysql",
+    'mssql' = "mssql",
+    'postgres' = "postgres",
+    'cockroach' = "cockroach",
+    'api' = "api",
+    'graphql' = "graphql",
+    'snowflake' = "snowflake",
+    'datadog' = "datadog",
+    'newrelic' = "newrelic",
+    'auth0' = "auth0",
+    'jwt_rsa' = "jwt_rsa",
+    'jwt_hmac' = "jwt_hmac",
+    'ai_assistant' = "ai_assistant",
+    'algolia' = "algolia",
+    'elastic_observability' = "elastic_observability",
+    'elastic_search' = "elastic_search",
+    'elastic_enterprise_search' = "elastic_enterprise_search",
+    'sentry' = "sentry",
+    'sap_hana' = "sap_hana",
+    'salesforce_crm' = "salesforce_crm",
+    'documentdb' = "documentdb",
+    'dynamodb' = "dynamodb",
+    'cassandra' = "cassandra",
+    'clickhouse' = "clickhouse",
+    'alloydb' = "alloydb",
+    'spanner' = "spanner",
+    'db2' = "db2",
+    'mariadb' = "mariadb",
+    'oracledb' = "oracledb",
+    'redis' = "redis",
+    'xata' = "xata",
+    'azure_sql' = "azure_sql"
+}
+export interface IntegrationConfigTypes {
+    [IntegrationType.built_in_db]: InternalIntegrationConfig;
+    [IntegrationType.mongo]: MongoIntegrationConfig;
+    [IntegrationType.mysql]: MySqlIntegrationConfig;
+    [IntegrationType.oracledb]: OracleIntegrationConfig;
+    [IntegrationType.mssql]: MssqlIntegrationConfig;
+    [IntegrationType.postgres]: PostgresIntegrationConfig;
+    [IntegrationType.cockroach]: CockroachIntegrationConfig;
+    [IntegrationType.snowflake]: SnowflakeIntegrationConfig;
+    [IntegrationType.api]: HttpApiIntegrationConfig;
+    [IntegrationType.graphql]: GraphQLIntegrationConfig;
+    [IntegrationType.datadog]: DatadogIntegrationConfig;
+    [IntegrationType.newrelic]: NewRelicIntegrationConfig;
+    [IntegrationType.auth0]: Auth0IntegrationConfig;
+    [IntegrationType.jwt_rsa]: JwtRsaIntegrationConfig;
+    [IntegrationType.jwt_hmac]: JwtHmacIntegrationConfig;
+    [IntegrationType.ai_assistant]: AiAssistantIntegrationConfig;
+}
+export declare const DatabaseIntegrationTypes: readonly [IntegrationType.built_in_db, IntegrationType.mongo, IntegrationType.mysql, IntegrationType.mssql, IntegrationType.postgres, IntegrationType.cockroach, IntegrationType.snowflake, IntegrationType.oracledb];
+export type DatabaseIntegrationType = (typeof DatabaseIntegrationTypes)[number];
+export type DatabaseIntegrationConfig = IntegrationConfigTypes[DatabaseIntegrationType];
+export declare const ApiIntegrationTypes: readonly [IntegrationType.api, IntegrationType.graphql];
+export declare const ObservabilityIntegrationTypes: readonly [IntegrationType.datadog, IntegrationType.newrelic];
+export declare const AuthIntegrationTypes: readonly [IntegrationType.auth0, IntegrationType.jwt_rsa, IntegrationType.jwt_hmac];
+export type ApiIntegrationType = (typeof ApiIntegrationTypes)[number];
+export type ApiIntegrationConfig = IntegrationConfigTypes[ApiIntegrationType];
+export type ObservabilityIntegrationType = (typeof ObservabilityIntegrationTypes)[number];
+export type ObservabilityIntegrationConfig = IntegrationConfigTypes[ObservabilityIntegrationType];
+export type AuthIntegrationType = (typeof AuthIntegrationTypes)[number];
+export type AuthIntegrationConfig = IntegrationConfigTypes[AuthIntegrationType];
+export declare function isDataIntegrationType(type: IntegrationType): type is DatabaseIntegrationType;
+export declare function isDataIntegration(integration: any): integration is BaseDatabaseIntegrationConfig;
+export declare function isAuthIntegrationType(type: IntegrationType): type is AuthIntegrationType;
+export declare function isAuthIntegration(integration: any): integration is AuthIntegrationConfig;
+export type IntegrationConfig = DatabaseIntegrationConfig | ApiIntegrationConfig | ObservabilityIntegrationConfig | AuthIntegrationConfig | AiAssistantIntegrationConfig;
+export interface BaseIntegrationConfig {
+    id: IntegrationId;
+    type: IntegrationType;
+    creationDate: Date;
+    updateDate: Date;
+}
+export type TestConnectionRequest = TestDataConnectionRequest | TestGraphQLDataConnectionRequest;

package/dist/common/src/integrations/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthIntegration = exports.isAuthIntegrationType = exports.isDataIntegration = exports.isDataIntegrationType = exports.AuthIntegrationTypes = exports.ObservabilityIntegrationTypes = exports.ApiIntegrationTypes = exports.DatabaseIntegrationTypes = exports.IntegrationType = exports.IntegrationCategory = void 0;
+__exportStar(require("./ai_assistant.types"), exports);
+__exportStar(require("./api.types"), exports);
+__exportStar(require("./auth.types"), exports);
+__exportStar(require("./database.types"), exports);
+__exportStar(require("./observability.types"), exports);
+var IntegrationCategory;
+(function (IntegrationCategory) {
+    IntegrationCategory["database"] = "database";
+    IntegrationCategory["api"] = "api";
+    IntegrationCategory["observability"] = "observability";
+    IntegrationCategory["crm"] = "crm";
+    IntegrationCategory["auth"] = "auth";
+    IntegrationCategory["ai"] = "ai";
+})(IntegrationCategory = exports.IntegrationCategory || (exports.IntegrationCategory = {}));
+var IntegrationType;
+(function (IntegrationType) {
+    IntegrationType["built_in_db"] = "built_in_db";
+    IntegrationType["mongo"] = "mongo";
+    IntegrationType["mysql"] = "mysql";
+    IntegrationType["mssql"] = "mssql";
+    IntegrationType["postgres"] = "postgres";
+    IntegrationType["cockroach"] = "cockroach";
+    IntegrationType["api"] = "api";
+    IntegrationType["graphql"] = "graphql";
+    IntegrationType["snowflake"] = "snowflake";
+    IntegrationType["datadog"] = "datadog";
+    IntegrationType["newrelic"] = "newrelic";
+    IntegrationType["auth0"] = "auth0";
+    IntegrationType["jwt_rsa"] = "jwt_rsa";
+    IntegrationType["jwt_hmac"] = "jwt_hmac";
+    IntegrationType["ai_assistant"] = "ai_assistant";
+    IntegrationType["algolia"] = "algolia";
+    IntegrationType["elastic_observability"] = "elastic_observability";
+    IntegrationType["elastic_search"] = "elastic_search";
+    IntegrationType["elastic_enterprise_search"] = "elastic_enterprise_search";
+    IntegrationType["sentry"] = "sentry";
+    IntegrationType["sap_hana"] = "sap_hana";
+    IntegrationType["salesforce_crm"] = "salesforce_crm";
+    IntegrationType["documentdb"] = "documentdb";
+    IntegrationType["dynamodb"] = "dynamodb";
+    IntegrationType["cassandra"] = "cassandra";
+    IntegrationType["clickhouse"] = "clickhouse";
+    IntegrationType["alloydb"] = "alloydb";
+    IntegrationType["spanner"] = "spanner";
+    IntegrationType["db2"] = "db2";
+    IntegrationType["mariadb"] = "mariadb";
+    IntegrationType["oracledb"] = "oracledb";
+    IntegrationType["redis"] = "redis";
+    IntegrationType["xata"] = "xata";
+    IntegrationType["azure_sql"] = "azure_sql";
+})(IntegrationType = exports.IntegrationType || (exports.IntegrationType = {}));
+exports.DatabaseIntegrationTypes = [
+    IntegrationType.built_in_db,
+    IntegrationType.mongo,
+    IntegrationType.mysql,
+    IntegrationType.mssql,
+    IntegrationType.postgres,
+    IntegrationType.cockroach,
+    IntegrationType.snowflake,
+    IntegrationType.oracledb,
+];
+exports.ApiIntegrationTypes = [IntegrationType.api, IntegrationType.graphql];
+exports.ObservabilityIntegrationTypes = [IntegrationType.datadog, IntegrationType.newrelic];
+exports.AuthIntegrationTypes = [IntegrationType.auth0, IntegrationType.jwt_rsa, IntegrationType.jwt_hmac];
+function isDataIntegrationType(type) {
+    return exports.DatabaseIntegrationTypes.includes(type);
+}
+exports.isDataIntegrationType = isDataIntegrationType;
+function isDataIntegration(integration) {
+    return isDataIntegrationType(integration.type);
+}
+exports.isDataIntegration = isDataIntegration;
+function isAuthIntegrationType(type) {
+    return exports.AuthIntegrationTypes.includes(type);
+}
+exports.isAuthIntegrationType = isAuthIntegrationType;
+function isAuthIntegration(integration) {
+    return isAuthIntegrationType(integration.type);
+}
+exports.isAuthIntegration = isAuthIntegration;
+//# sourceMappingURL=index.js.map

package/dist/common/src/integrations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../common/src/integrations/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,8CAA4B;AAC5B,+CAA6B;AAC7B,mDAAiC;AACjC,wDAAsC;AAoBtC,IAAY,mBAOX;AAPD,WAAY,mBAAmB;IAC7B,4CAAuB,CAAA;IACvB,kCAAa,CAAA;IACb,sDAAiC,CAAA;IACjC,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,gCAAW,CAAA;AACb,CAAC,EAPW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAO9B;AAED,IAAY,eAoCX;AApCD,WAAY,eAAe;IACzB,8CAA6B,CAAA;IAC7B,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;IACjB,kCAAiB,CAAA;IACjB,wCAAuB,CAAA;IACvB,0CAAyB,CAAA;IACzB,8BAAa,CAAA;IACb,sCAAqB,CAAA;IACrB,0CAAyB,CAAA;IACzB,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,kCAAiB,CAAA;IACjB,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,gDAA+B,CAAA;IAE/B,sCAAqB,CAAA;IACrB,kEAAiD,CAAA;IACjD,oDAAmC,CAAA;IACnC,0EAAyD,CAAA;IACzD,oCAAmB,CAAA;IACnB,wCAAuB,CAAA;IACvB,oDAAmC,CAAA;IACnC,4CAA2B,CAAA;IAC3B,wCAAuB,CAAA;IACvB,0CAAyB,CAAA;IACzB,4CAA2B,CAAA;IAC3B,sCAAqB,CAAA;IACrB,sCAAqB,CAAA;IACrB,8BAAa,CAAA;IACb,sCAAqB,CAAA;IACrB,wCAAuB,CAAA;IACvB,kCAAiB,CAAA;IACjB,gCAAe,CAAA;IACf,0CAAyB,CAAA;AAC3B,CAAC,EApCW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAoC1B;AAqBY,QAAA,wBAAwB,GAAG;IACtC,eAAe,CAAC,WAAW;IAC3B,eAAe,CAAC,KAAK;IACrB,eAAe,CAAC,KAAK;IACrB,eAAe,CAAC,KAAK;IACrB,eAAe,CAAC,QAAQ;IACxB,eAAe,CAAC,SAAS;IACzB,eAAe,CAAC,SAAS;IACzB,eAAe,CAAC,QAAQ;CAChB,CAAC;AAIE,QAAA,mBAAmB,GAAG,CAAC,eAAe,CAAC,GAAG,EAAE,eAAe,CAAC,OAAO,CAAU,CAAC;AAE9E,QAAA,6BAA6B,GAAG,CAAC,eAAe,CAAC,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAU,CAAC;AAE7F,QAAA,oBAAoB,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAU,CAAC;AAWxH,SAAgB,qBAAqB,CAAC,IAAqB;IACzD,OAAQ,gCAAuD,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACjF,CAAC;AAFD,sDAEC;AAED,SAAgB,iBAAiB,CAAC,WAAgB;IAChD,OAAO,qBAAqB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AACjD,CAAC;AAFD,8CAEC;AAED,SAAgB,qBAAqB,CAAC,IAAqB;IACzD,OAAQ,4BAAmD,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC7E,CAAC;AAFD,sDAEC;AAED,SAAgB,iBAAiB,CAAC,WAAgB;IAChD,OAAO,qBAAqB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AACjD,CAAC;AAFD,8CAEC"}

package/dist/common/src/integrations/observability.types.d.ts

@@ -0,0 +1,22 @@
+import { BaseIntegrationConfig, IntegrationType } from './index';
+export interface DatadogIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.datadog;
+    configuration: DatadogIntegrationConfiguration;
+}
+export interface NewRelicIntegrationConfig extends BaseIntegrationConfig {
+    type: IntegrationType.newrelic;
+    configuration: NewRelicIntegrationConfiguration;
+}
+export type DatadogRegion = 'us1' | 'us3' | 'us5' | 'eu1' | 'us1-fed';
+export declare const datadogRegionMap: Record<DatadogRegion, string>;
+export interface DatadogIntegrationConfiguration {
+    apiKey: string;
+    appKey: string;
+    datadogRegion: DatadogRegion;
+}
+export type NewRelicRegion = 'worldwide' | 'eu';
+export declare const newRelicRegionMap: Record<NewRelicRegion, string>;
+export interface NewRelicIntegrationConfiguration {
+    apiKey: string;
+    newRelicRegion: NewRelicRegion;
+}

package/dist/common/src/integrations/observability.types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newRelicRegionMap = exports.datadogRegionMap = void 0;
+exports.datadogRegionMap = {
+    us1: 'US1 - East',
+    us3: 'US3 - West',
+    us5: 'US5 - Central',
+    eu1: 'EU1 - Europe',
+    'us1-fed': 'US1-FED (FedRamp)',
+};
+exports.newRelicRegionMap = {
+    worldwide: 'Worldwide',
+    eu: 'Europe',
+};
+//# sourceMappingURL=observability.types.js.map

package/dist/common/src/integrations/observability.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.types.js","sourceRoot":"","sources":["../../../../../common/src/integrations/observability.types.ts"],"names":[],"mappings":";;;AAca,QAAA,gBAAgB,GAAkC;IAC7D,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,cAAc;IACnB,SAAS,EAAE,mBAAmB;CAC/B,CAAC;AAUW,QAAA,iBAAiB,GAAmC;IAC/D,SAAS,EAAE,WAAW;IACtB,EAAE,EAAE,QAAQ;CACb,CAAC"}

package/dist/common/src/logger.types.d.ts

@@ -0,0 +1,21 @@
+export type LoggerContext = Record<string, any>;
+export interface Logger {
+    trace(message: string, context?: LoggerContext): void;
+    debug(message: string, context?: LoggerContext): void;
+    info(message: string, context?: LoggerContext): void;
+    warn(message: string, context?: LoggerContext): void;
+    error(message: string, context?: LoggerContext): void;
+    log(record: LogRecord): void;
+}
+export declare enum LogLevel {
+    TRACE = "trace",
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}
+export interface LogRecord {
+    level?: LogLevel;
+    message?: string;
+    [key: string]: any;
+}

package/dist/common/src/logger.types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["TRACE"] = "trace";
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+//# sourceMappingURL=logger.types.js.map

package/dist/common/src/logger.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.types.js","sourceRoot":"","sources":["../../../../common/src/logger.types.ts"],"names":[],"mappings":";;;AAgBA,IAAY,QAMX;AAND,WAAY,QAAQ;IAClB,2BAAe,CAAA;IACf,2BAAe,CAAA;IACf,yBAAa,CAAA;IACb,yBAAa,CAAA;IACb,2BAAe,CAAA;AACjB,CAAC,EANW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAMnB"}