@mitralab.io/sdk-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,443 @@
+"use strict";
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SdkCoreConfigurationError: () => SdkCoreConfigurationError,
+  SdkCoreResponseError: () => SdkCoreResponseError,
+  createAuthModule: () => createAuthModule,
+  createEntitiesModule: () => createEntitiesModule,
+  createFunctionsModule: () => createFunctionsModule,
+  createIntegrationModule: () => createIntegrationModule,
+  createQueriesModule: () => createQueriesModule,
+  createSdkCore: () => createSdkCore,
+  defaultSdkCoreErrorFactory: () => defaultSdkCoreErrorFactory,
+  encodePathSegment: () => encodePathSegment,
+  expectEmpty: () => expectEmpty,
+  expectObject: () => expectObject,
+  expectObjectArray: () => expectObjectArray
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SdkCoreConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SdkCoreConfigurationError";
+  }
+};
+var SdkCoreResponseError = class extends Error {
+  code = "INVALID_RESPONSE";
+  retryable = false;
+  constructor(message) {
+    super(message);
+    this.name = "SdkCoreResponseError";
+  }
+};
+var defaultSdkCoreErrorFactory = {
+  configuration: (message) => new SdkCoreConfigurationError(message),
+  invalidResponse: (message) => new SdkCoreResponseError(message)
+};
+function configurationError(message, errors = defaultSdkCoreErrorFactory) {
+  throw errors.configuration(message);
+}
+function invalidResponse(message, errors = defaultSdkCoreErrorFactory) {
+  throw errors.invalidResponse(message);
+}
+
+// src/response.ts
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isInteger(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function isNullableInteger(value) {
+  return value === null || isInteger(value);
+}
+function isStringRecord(value) {
+  return isObject(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function hasOwn(value, property) {
+  return Object.prototype.hasOwnProperty.call(value, property);
+}
+function invalidField(context, field, errors) {
+  return invalidResponse(`${context} has an invalid ${field} field`, errors);
+}
+function expectObject(value, context, errors = defaultSdkCoreErrorFactory) {
+  if (!isObject(value)) {
+    return invalidResponse(`${context} must be a JSON object`, errors);
+  }
+  return value;
+}
+function expectObjectArray(value, context, errors = defaultSdkCoreErrorFactory) {
+  if (!Array.isArray(value) || value.some((item) => !isObject(item))) {
+    return invalidResponse(`${context} must be a JSON array of objects`, errors);
+  }
+  return value;
+}
+function expectTenant(value, context, errors = defaultSdkCoreErrorFactory) {
+  const tenant = expectObject(value, context, errors);
+  if (typeof tenant.id !== "string") invalidField(context, "id", errors);
+  if (typeof tenant.shortId !== "string") invalidField(context, "shortId", errors);
+  if (!isNullableInteger(tenant.legacyId)) invalidField(context, "legacyId", errors);
+  if (typeof tenant.slug !== "string") invalidField(context, "slug", errors);
+  if (!isObject(tenant.plan)) invalidField(context, "plan", errors);
+  if (typeof tenant.plan.id !== "string") invalidField(`${context} plan`, "id", errors);
+  if (typeof tenant.plan.name !== "string") invalidField(`${context} plan`, "name", errors);
+  if (typeof tenant.name !== "string") invalidField(context, "name", errors);
+  if (!isNullableString(tenant.description)) invalidField(context, "description", errors);
+  if (!isNullableString(tenant.hexColor)) invalidField(context, "hexColor", errors);
+  if (!isNullableString(tenant.icon)) invalidField(context, "icon", errors);
+  if (typeof tenant.infraStatus !== "string") invalidField(context, "infraStatus", errors);
+  if (typeof tenant.active !== "boolean") invalidField(context, "active", errors);
+  return tenant;
+}
+function expectUser(value, context, errors = defaultSdkCoreErrorFactory) {
+  const user = expectObject(value, context, errors);
+  if (typeof user.id !== "string") invalidField(context, "id", errors);
+  expectTenant(user.tenant, `${context} tenant`, errors);
+  if (typeof user.name !== "string") invalidField(context, "name", errors);
+  if (typeof user.email !== "string") invalidField(context, "email", errors);
+  if (!isNullableString(user.imageUrl)) invalidField(context, "imageUrl", errors);
+  if (typeof user.onboardingCompleted !== "boolean") {
+    invalidField(context, "onboardingCompleted", errors);
+  }
+  return user;
+}
+function expectQueryResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!Array.isArray(result.rows) || result.rows.some((row) => !isObject(row))) {
+    invalidField(context, "rows", errors);
+  }
+  if (hasOwn(result, "affectedRows") && !isNullableInteger(result.affectedRows)) {
+    invalidField(context, "affectedRows", errors);
+  }
+  if (!isInteger(result.durationMs)) {
+    invalidField(context, "durationMs", errors);
+  }
+  return result;
+}
+function expectFunctionExecution(value, context, errors = defaultSdkCoreErrorFactory) {
+  const execution = expectObject(value, context, errors);
+  if (typeof execution.id !== "string") invalidField(context, "id", errors);
+  if (typeof execution.functionId !== "string") invalidField(context, "functionId", errors);
+  if (typeof execution.functionVersionId !== "string") {
+    invalidField(context, "functionVersionId", errors);
+  }
+  if (typeof execution.status !== "string") invalidField(context, "status", errors);
+  if (execution.input !== null && !isObject(execution.input)) {
+    invalidField(context, "input", errors);
+  }
+  if (execution.output !== null && !isObject(execution.output)) {
+    invalidField(context, "output", errors);
+  }
+  if (!isNullableString(execution.errorMessage)) {
+    invalidField(context, "errorMessage", errors);
+  }
+  if (!isNullableString(execution.logs)) invalidField(context, "logs", errors);
+  if (!isNullableInteger(execution.durationMs)) invalidField(context, "durationMs", errors);
+  if (!isNullableString(execution.startedAt)) invalidField(context, "startedAt", errors);
+  if (!isNullableString(execution.finishedAt)) invalidField(context, "finishedAt", errors);
+  if (typeof execution.createdAt !== "string") invalidField(context, "createdAt", errors);
+  return execution;
+}
+function expectProxyResult(value, context, errors = defaultSdkCoreErrorFactory) {
+  const result = expectObject(value, context, errors);
+  if (!isInteger(result.status)) {
+    invalidField(context, "status", errors);
+  }
+  if (!isStringRecord(result.headers)) invalidField(context, "headers", errors);
+  if (!hasOwn(result, "body")) invalidField(context, "body", errors);
+  if (!isInteger(result.durationMs)) {
+    invalidField(context, "durationMs", errors);
+  }
+  if (typeof result.executionId !== "string") invalidField(context, "executionId", errors);
+  return result;
+}
+function expectEmpty(value, context, errors = defaultSdkCoreErrorFactory) {
+  if (value !== void 0) invalidResponse(`${context} must be empty`, errors);
+}
+
+// src/modules/auth.ts
+function createAuthModule(transport, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async me() {
+      return expectUser(
+        await transport.request("/api/v1/auth/me", { method: "GET" }),
+        "Current user response",
+        errors
+      );
+    }
+  };
+}
+
+// src/path.ts
+function encodePathSegment(value, name, errors = defaultSdkCoreErrorFactory) {
+  const segment = String(value);
+  if (!segment.trim()) configurationError(`${name} must not be empty`, errors);
+  if (segment === "." || segment === "..") {
+    configurationError(`${name} must not be a dot segment`, errors);
+  }
+  return encodeURIComponent(segment);
+}
+
+// src/modules/entities.ts
+var DefaultEntitiesModule = class {
+  constructor(transport, errors) {
+    this.transport = transport;
+    this.errors = errors;
+  }
+  tables = /* @__PURE__ */ new Map();
+  getTable(tableName) {
+    if (!this.tables.has(tableName)) {
+      this.tables.set(tableName, this.createTable(tableName));
+    }
+    return this.tables.get(tableName);
+  }
+  createTable(tableName) {
+    const basePath = `/api/v1/tables/${encodePathSegment(tableName, "tableName", this.errors)}/records`;
+    return {
+      list: async (sortOrOptions, limit, skip, fields) => {
+        const options = typeof sortOrOptions === "object" ? sortOrOptions : void 0;
+        const params = {
+          sort: options?.sort ?? (typeof sortOrOptions === "string" ? sortOrOptions : void 0),
+          limit: options?.limit ?? limit,
+          skip: options?.skip ?? skip,
+          fields: (options?.fields ?? fields)?.join(",")
+        };
+        const response = expectObject(
+          await this.transport.request(basePath, { method: "GET", params }),
+          "Entity list response",
+          this.errors
+        );
+        return expectObjectArray(response.data, "Entity list data", this.errors);
+      },
+      filter: async (query, sort, limit, skip, fields) => {
+        const response = expectObject(
+          await this.transport.request(basePath, {
+            method: "GET",
+            params: {
+              q: JSON.stringify(query),
+              sort,
+              limit,
+              skip,
+              fields: fields?.join(",")
+            }
+          }),
+          "Entity list response",
+          this.errors
+        );
+        return expectObjectArray(response.data, "Entity list data", this.errors);
+      },
+      get: async (id) => expectObject(
+        await this.transport.request(
+          `${basePath}/${encodePathSegment(id, "id", this.errors)}`,
+          { method: "GET" }
+        ),
+        "Entity response",
+        this.errors
+      ),
+      create: async (data) => expectObject(
+        await this.transport.request(basePath, { method: "POST", body: data }),
+        "Created entity response",
+        this.errors
+      ),
+      bulkCreate: async (data) => expectObjectArray(
+        await this.transport.request(`${basePath}/bulk`, {
+          method: "POST",
+          body: data
+        }),
+        "Bulk create response",
+        this.errors
+      ),
+      update: async (id, data) => expectObject(
+        await this.transport.request(
+          `${basePath}/${encodePathSegment(id, "id", this.errors)}`,
+          { method: "PUT", body: data }
+        ),
+        "Updated entity response",
+        this.errors
+      ),
+      delete: (id) => this.transport.request(`${basePath}/${encodePathSegment(id, "id", this.errors)}`, {
+        method: "DELETE"
+      }).then((response) => expectEmpty(response, "Delete entity response", this.errors)),
+      deleteMany: async (query) => {
+        if (Object.keys(query).length === 0) {
+          configurationError("query must not be empty for deleteMany", this.errors);
+        }
+        const response = expectObject(
+          await this.transport.request(basePath, {
+            method: "DELETE",
+            params: { q: JSON.stringify(query) }
+          }),
+          "Delete many response",
+          this.errors
+        );
+        if (!Number.isInteger(response.deleted)) {
+          return invalidResponse(
+            "Delete many response must include an integer deleted count",
+            this.errors
+          );
+        }
+        return { deleted: response.deleted };
+      }
+    };
+  }
+};
+function createEntitiesModule(transport, errors = defaultSdkCoreErrorFactory) {
+  const instance = new DefaultEntitiesModule(transport, errors);
+  return new Proxy(instance, {
+    get(target, property, receiver) {
+      if (typeof property !== "string" || property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      return target.getTable(property);
+    }
+  });
+}
+
+// src/modules/functions.ts
+var DefaultFunctionsModule = class {
+  constructor(transport, errors, options) {
+    this.transport = transport;
+    this.errors = errors;
+    this.options = options;
+  }
+  execute(id, input) {
+    return this.executeWithType(id, this.options.executeInvocationType, input);
+  }
+  executeAsync(id, input) {
+    return this.executeWithType(id, "async", input);
+  }
+  getExecution(id) {
+    return this.transport.request(
+      `/api/v1/executions/${encodePathSegment(id, "execution id", this.errors)}`,
+      { method: "GET" }
+    ).then(
+      (response) => expectFunctionExecution(response, "Function execution response", this.errors)
+    );
+  }
+  cancelExecution(id) {
+    return this.transport.request(
+      `/api/v1/executions/${encodePathSegment(id, "execution id", this.errors)}/cancel`,
+      { method: "POST" }
+    ).then((response) => expectEmpty(response, "Cancel execution response", this.errors));
+  }
+  executeWithType(id, invocationType, input) {
+    const request = {
+      method: "POST",
+      ...input !== void 0 || this.options.emptyInput !== "omit-body" ? { body: { input: input ?? {} } } : {},
+      ...invocationType === void 0 ? {} : { headers: { "X-Invocation-Type": invocationType } }
+    };
+    return this.transport.request(
+      `/api/v1/functions/${encodePathSegment(id, "function id", this.errors)}/execute`,
+      request
+    ).then(
+      (response) => expectFunctionExecution(response, "Function execution response", this.errors)
+    );
+  }
+};
+function createFunctionsModule(transport, options = {}, errors = defaultSdkCoreErrorFactory) {
+  return new DefaultFunctionsModule(transport, errors, options);
+}
+
+// src/modules/integration.ts
+function createIntegrationModule(transport, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async executeResource(resourceId, params = {}) {
+      return expectProxyResult(
+        await transport.request(
+          `/api/v1/proxy/resources/${encodePathSegment(resourceId, "resource id", errors)}/execute`,
+          { method: "POST", body: { params } }
+        ),
+        "Integration resource response",
+        errors
+      );
+    },
+    async execute(configId, request) {
+      return expectProxyResult(
+        await transport.request(
+          `/api/v1/proxy/template-configs/${encodePathSegment(configId, "config id", errors)}/execute`,
+          { method: "POST", body: { ...request, source: "SDK" } }
+        ),
+        "Integration proxy response",
+        errors
+      );
+    }
+  };
+}
+
+// src/modules/queries.ts
+function createQueriesModule(transport, getDataSourceId, errors = defaultSdkCoreErrorFactory) {
+  return {
+    async execute(id, parameters = {}) {
+      const dataSourceId = getDataSourceId();
+      if (!dataSourceId) {
+        configurationError(
+          "A dataSourceId is required for queries. Call client.init() first or configure dataSourceId.",
+          errors
+        );
+      }
+      return expectQueryResult(
+        await transport.request(
+          `/api/v1/custom-queries/${encodePathSegment(id, "query id", errors)}/execute`,
+          {
+            method: "POST",
+            body: { dataSourceId, parameters }
+          }
+        ),
+        "Query execution response",
+        errors
+      );
+    }
+  };
+}
+
+// src/core.ts
+function createSdkCore(options) {
+  const errors = options.errors ?? defaultSdkCoreErrorFactory;
+  return {
+    auth: createAuthModule(options.transports.auth, errors),
+    entities: createEntitiesModule(options.transports.dataManager, errors),
+    functions: createFunctionsModule(options.transports.functions, options.functions, errors),
+    integration: createIntegrationModule(options.transports.integration, errors),
+    queries: createQueriesModule(options.transports.dataManager, options.getDataSourceId, errors)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdkCoreConfigurationError,
+  SdkCoreResponseError,
+  createAuthModule,
+  createEntitiesModule,
+  createFunctionsModule,
+  createIntegrationModule,
+  createQueriesModule,
+  createSdkCore,
+  defaultSdkCoreErrorFactory,
+  encodePathSegment,
+  expectEmpty,
+  expectObject,
+  expectObjectArray
+});

package/dist/index.d.cts

@@ -0,0 +1,171 @@
+interface SdkCoreErrorFactory {
+    configuration(message: string): Error;
+    invalidResponse(message: string): Error;
+}
+declare class SdkCoreConfigurationError extends Error {
+    constructor(message: string);
+}
+declare class SdkCoreResponseError extends Error {
+    readonly code = "INVALID_RESPONSE";
+    readonly retryable = false;
+    constructor(message: string);
+}
+declare const defaultSdkCoreErrorFactory: SdkCoreErrorFactory;
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+type QueryParamValue = string | number | boolean | undefined;
+interface TransportRequestOptions {
+    method?: HttpMethod;
+    body?: unknown;
+    headers?: Record<string, string>;
+    params?: Record<string, QueryParamValue>;
+}
+interface Transport {
+    request<T>(path: string, options?: TransportRequestOptions): Promise<T>;
+}
+
+interface Plan {
+    id: string;
+    name: string;
+    [key: string]: unknown;
+}
+interface Tenant {
+    id: string;
+    shortId: string;
+    legacyId: number | null;
+    slug: string;
+    plan: Plan;
+    name: string;
+    description: string | null;
+    hexColor: string | null;
+    icon: string | null;
+    infraStatus: string;
+    active: boolean;
+    [key: string]: unknown;
+}
+interface User {
+    id: string;
+    tenant: Tenant;
+    name: string;
+    email: string;
+    imageUrl: string | null;
+    onboardingCompleted: boolean;
+}
+interface EntityListOptions {
+    sort?: string;
+    limit?: number;
+    skip?: number;
+    fields?: string[];
+}
+interface EntityTable<T = Record<string, unknown>> {
+    list(sortOrOptions?: string | EntityListOptions, limit?: number, skip?: number, fields?: string[]): Promise<T[]>;
+    filter(query: Record<string, unknown>, sort?: string, limit?: number, skip?: number, fields?: string[]): Promise<T[]>;
+    get(id: string | number): Promise<T>;
+    create(data: Partial<T>): Promise<T>;
+    bulkCreate(data: Partial<T>[]): Promise<T[]>;
+    update(id: string | number, data: Partial<T>): Promise<T>;
+    delete(id: string | number): Promise<void>;
+    deleteMany(query: Record<string, unknown>): Promise<{
+        deleted: number;
+    }>;
+}
+interface QueryResult {
+    rows: Record<string, unknown>[];
+    affectedRows?: number | null;
+    durationMs: number;
+}
+interface FunctionExecution {
+    id: string;
+    functionId: string;
+    functionVersionId: string;
+    status: string;
+    input: Record<string, unknown> | null;
+    output: Record<string, unknown> | null;
+    errorMessage: string | null;
+    logs: string | null;
+    durationMs: number | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    createdAt: string;
+}
+interface ProxyInput {
+    method: string;
+    endpoint: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    queryParams?: Record<string, unknown>;
+}
+interface ProxyResult {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+    durationMs: number;
+    executionId: string;
+}
+
+interface AuthModule {
+    me(): Promise<User>;
+}
+declare function createAuthModule(transport: Transport, errors?: SdkCoreErrorFactory): AuthModule;
+
+interface EntitiesModule {
+    getTable<T = Record<string, unknown>>(tableName: string): EntityTable<T>;
+}
+type EntitiesProxy = EntitiesModule & {
+    [tableName: string]: EntityTable;
+};
+declare function createEntitiesModule(transport: Transport, errors?: SdkCoreErrorFactory): EntitiesProxy;
+
+type InvocationType = "sync" | "async";
+type EmptyFunctionInput = "empty-object" | "omit-body";
+interface FunctionsModuleOptions {
+    executeInvocationType?: InvocationType;
+    emptyInput?: EmptyFunctionInput;
+}
+interface FunctionsModule {
+    execute(id: string, input?: Record<string, unknown>): Promise<FunctionExecution>;
+    executeAsync(id: string, input?: Record<string, unknown>): Promise<FunctionExecution>;
+    getExecution(id: string): Promise<FunctionExecution>;
+    cancelExecution(id: string): Promise<void>;
+}
+declare function createFunctionsModule(transport: Transport, options?: FunctionsModuleOptions, errors?: SdkCoreErrorFactory): FunctionsModule;
+
+interface IntegrationModule {
+    executeResource(resourceId: string, params?: Record<string, unknown>): Promise<ProxyResult>;
+    execute(configId: string, request: ProxyInput): Promise<ProxyResult>;
+}
+declare function createIntegrationModule(transport: Transport, errors?: SdkCoreErrorFactory): IntegrationModule;
+
+interface QueriesModule {
+    execute(id: string, parameters?: Record<string, unknown>): Promise<QueryResult>;
+}
+declare function createQueriesModule(transport: Transport, getDataSourceId: () => string | undefined, errors?: SdkCoreErrorFactory): QueriesModule;
+
+interface SdkCoreTransports {
+    auth: Transport;
+    dataManager: Transport;
+    functions: Transport;
+    integration: Transport;
+}
+interface SdkCoreOptions {
+    transports: SdkCoreTransports;
+    getDataSourceId: () => string | undefined;
+    functions?: FunctionsModuleOptions;
+    errors?: SdkCoreErrorFactory;
+}
+interface SdkCore {
+    readonly auth: AuthModule;
+    readonly entities: EntitiesProxy;
+    readonly functions: FunctionsModule;
+    readonly integration: IntegrationModule;
+    readonly queries: QueriesModule;
+}
+declare function createSdkCore(options: SdkCoreOptions): SdkCore;
+
+declare function encodePathSegment(value: string | number, name: string, errors?: SdkCoreErrorFactory): string;
+
+declare function expectObject<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory): T;
+declare function expectObjectArray<T extends object>(value: unknown, context: string, errors?: SdkCoreErrorFactory): T[];
+declare function expectEmpty(value: unknown, context: string, errors?: SdkCoreErrorFactory): void;
+
+export { type AuthModule, type EmptyFunctionInput, type EntitiesModule, type EntitiesProxy, type EntityListOptions, type EntityTable, type FunctionExecution, type FunctionsModule, type FunctionsModuleOptions, type HttpMethod, type IntegrationModule, type InvocationType, type Plan, type ProxyInput, type ProxyResult, type QueriesModule, type QueryParamValue, type QueryResult, type SdkCore, SdkCoreConfigurationError, type SdkCoreErrorFactory, type SdkCoreOptions, SdkCoreResponseError, type SdkCoreTransports, type Tenant, type Transport, type TransportRequestOptions, type User, createAuthModule, createEntitiesModule, createFunctionsModule, createIntegrationModule, createQueriesModule, createSdkCore, defaultSdkCoreErrorFactory, encodePathSegment, expectEmpty, expectObject, expectObjectArray };