@datalayer/core 1.1.59 → 1.1.66

package/scripts/generate-mcp-types.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+# Copyright (c) 2023-2025 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+# Copyright (c) 2023-2026 Datalayer, Inc.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Generate deterministic TypeScript wire types from the Jupyter MCP Server's
+OpenAPI document, on the `generate-contents-types.py` pattern.
+
+The gateway keeps no contract file: its FastAPI application *is* the
+contract, and the document is read from it — imported from the sibling
+checkout of the service when there is one, otherwise fetched from a running
+gateway. `DATALAYER_JUPYTER_MCP_OPENAPI` names either a file or an URL and
+wins over both; the deployed gateway publishes its document without
+authentication at ``/api/mcp/v1/openapi.json``.
+
+What is written to ``src/api/mcp/generated.ts``:
+
+- one ``interface`` or ``type`` per ``components.schemas`` entry, snake case
+  turned to camel case as the Contents generator does;
+- ``MCP_GATEWAY_ROUTES``: the routes the document declares, with method,
+  path, operation id and parameters, so a client that names a route the
+  gateway dropped fails to type-check rather than at runtime.
+
+``--check`` exits non-zero when the checked-in file differs from what the
+document gives — the CI check that the file is current.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.request import Request, urlopen
+
+ROOT = Path(__file__).parents[1]
+DEFAULT_GATEWAY_CHECKOUT = ROOT.parents[2] / "k8s/services/jupyter-mcp-server"
+DEFAULT_GATEWAY_OPENAPI_URL = "https://mcp.datalayer.run/api/mcp/v1/openapi.json"
+GATEWAY_APP = "datalayer_jupyter_mcp_server.main:app"
+OUTPUT = ROOT / "src/api/mcp/generated.ts"
+#: The licence header every source file in this repository carries. It is
+#: emitted here because `fix-license-header` adds it to whatever this writes,
+#: and then `--check` compares that against output that never had one — so the
+#: two CI jobs each broke the other, permanently, and the check was red for
+#: reasons that had nothing to do with the types. It stayed red long enough
+#: for a dozen MCP routes to drift without anybody being able to see it.
+LICENCE = (
+    "/*\n"
+    " * Copyright (c) 2023-2025 Datalayer, Inc.\n"
+    " * Distributed under the terms of the Modified BSD License.\n"
+    " */"
+)
+
+HEADER = "/* This file is generated from the Datalayer Jupyter MCP Server OpenAPI. Do not edit. */"
+
+
+def type_name(reference: str) -> str:
+    return reference.rsplit("/", 1)[-1]
+
+
+def ts_type(schema: dict[str, Any]) -> str:
+    if "$ref" in schema:
+        return type_name(schema["$ref"])
+    if "const" in schema:
+        return json.dumps(schema["const"])
+    if "enum" in schema:
+        return " | ".join(json.dumps(value) for value in schema["enum"])
+    if "oneOf" in schema:
+        return " | ".join(ts_type(item) for item in schema["oneOf"])
+    if "anyOf" in schema:
+        return " | ".join(ts_type(item) for item in schema["anyOf"])
+    kind = schema.get("type")
+    if isinstance(kind, list):
+        return " | ".join(
+            "null" if item == "null" else ts_type({"type": item}) for item in kind
+        )
+    if kind == "array":
+        return f"Array<{ts_type(schema.get('items', {}))}>"
+    if kind == "object":
+        additional = schema.get("additionalProperties")
+        return (
+            f"Record<string, {ts_type(additional)}>"
+            if isinstance(additional, dict)
+            else "Record<string, unknown>"
+        )
+    if kind in {"integer", "number"}:
+        return "number"
+    if kind == "boolean":
+        return "boolean"
+    if kind == "null":
+        return "null"
+    if kind == "string":
+        return "string"
+    return "unknown"
+
+
+def camel(name: str) -> str:
+    parts = name.split("_")
+    return parts[0] + "".join(part[:1].upper() + part[1:] for part in parts[1:])
+
+
+def _read_from_checkout(checkout: Path) -> dict[str, Any] | None:
+    """The document of the application in a sibling checkout, in a subprocess.
+
+    A subprocess so the gateway's imports — its dependencies, its logging
+    configuration — never leak into this one, and so an environment that
+    cannot import it says so cleanly and the fetch takes over.
+    """
+    if not (checkout / "datalayer_jupyter_mcp_server").is_dir():
+        return None
+    module, _, attribute = GATEWAY_APP.partition(":")
+    code = (
+        "import json, sys\n"
+        f"from {module} import {attribute} as app\n"
+        "json.dump(app.openapi(), sys.stdout)\n"
+    )
+    completed = subprocess.run(
+        [sys.executable, "-c", code],
+        cwd=checkout,
+        capture_output=True,
+        text=True,
+        env={**os.environ, "LOG_LEVEL": "ERROR"},
+    )
+    if completed.returncode != 0:
+        sys.stderr.write(
+            f"Could not import {GATEWAY_APP} from {checkout}; "
+            "reading the deployed gateway instead.\n"
+        )
+        return None
+    return json.loads(completed.stdout)
+
+
+def _read_from_url(url: str) -> dict[str, Any]:
+    with urlopen(Request(url, headers={"Accept": "application/json"}), timeout=15) as response:
+        return json.load(response)
+
+
+def read_openapi() -> dict[str, Any]:
+    """The document, from the override, the sibling checkout or the deployed gateway."""
+    override = os.environ.get("DATALAYER_JUPYTER_MCP_OPENAPI", "").strip()
+    if override.startswith(("http://", "https://")):
+        return _read_from_url(override)
+    if override:
+        return json.loads(Path(override).read_text())
+    document = _read_from_checkout(DEFAULT_GATEWAY_CHECKOUT)
+    if document is not None:
+        return document
+    return _read_from_url(DEFAULT_GATEWAY_OPENAPI_URL)
+
+
+def _routes(document: dict[str, Any]) -> list[dict[str, Any]]:
+    routes = []
+    for path, operations in sorted(document.get("paths", {}).items()):
+        for method, operation in sorted(operations.items()):
+            if method.lower() not in {"get", "post", "put", "patch", "delete"}:
+                continue
+            routes.append(
+                {
+                    "method": method.upper(),
+                    "path": path,
+                    "operationId": operation.get("operationId", ""),
+                    "parameters": [
+                        {"name": parameter["name"], "in": parameter["in"]}
+                        for parameter in operation.get("parameters", [])
+                    ],
+                }
+            )
+    return routes
+
+
+def generate(document: dict[str, Any]) -> str:
+    schemas = (document.get("components") or {}).get("schemas") or {}
+    lines = [LICENCE, "", HEADER, ""]
+    for name, schema in sorted(schemas.items()):
+        if schema.get("type") == "object" and "properties" in schema:
+            lines.append(f"export interface {name} {{")
+            required = set(schema.get("required", []))
+            for property_name, property_schema in schema["properties"].items():
+                optional = "" if property_name in required else "?"
+                lines.append(
+                    f"  {camel(property_name)}{optional}: {ts_type(property_schema)};"
+                )
+            lines.extend(["}", ""])
+        else:
+            lines.extend([f"export type {name} = {ts_type(schema)};", ""])
+    lines.extend(
+        [
+            "/** One REST route the gateway declares. */",
+            "export interface McpGatewayRoute {",
+            "  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';",
+            "  path: string;",
+            "  operationId: string;",
+            "  parameters: Array<{ name: string; in: string }>;",
+            "}",
+            "",
+            f"/** The gateway version the routes were read from: {document.get('info', {}).get('version', '')}. */",
+            "export const MCP_GATEWAY_ROUTES: ReadonlyArray<McpGatewayRoute> = [",
+        ]
+    )
+    for route in _routes(document):
+        parameters = ", ".join(
+            f"{{ name: {json.dumps(p['name'])}, in: {json.dumps(p['in'])} }}"
+            for p in route["parameters"]
+        )
+        lines.append(
+            f"  {{ method: '{route['method']}', path: {json.dumps(route['path'])}, "
+            f"operationId: {json.dumps(route['operationId'])}, parameters: [{parameters}] }},"
+        )
+    lines.extend(["];", ""])
+    return "\n".join(lines)
+
+
+def main() -> None:
+    expected = generate(read_openapi())
+    if "--check" in sys.argv[1:]:
+        if not OUTPUT.exists() or OUTPUT.read_text() != expected:
+            raise SystemExit(
+                "Stale generated Jupyter MCP Server TypeScript types: "
+                "run `python scripts/generate-mcp-types.py`"
+            )
+        return
+    OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+    OUTPUT.write_text(expected)
+
+
+if __name__ == "__main__":
+    main()

package/lib/api/iam/datasources.d.ts

@@ -1,86 +0,0 @@
-import type { CreateDatasourceRequest, CreateDatasourceResponse, GetDatasourceResponse, ListDatasourcesResponse, UpdateDatasourceRequest, UpdateDatasourceResponse } from '../../models/Datasource';
-/**
- * Create a new datasource.
- * Creates a new datasource configuration for the authenticated user.
- *
- * @param token - Authentication token
- * @param data - Datasource creation data
- * @param baseUrl - Base URL for IAM service
- * @returns Created datasource data
- *
- * @example
- * ```typescript
- * const response = await createDatasource(token, {
- *   type: 'Amazon Athena',
- *   name: 'my-athena-datasource',
- *   description: 'Production Athena datasource',
- *   database: 'my_database',
- *   output_bucket: 's3://my-bucket/output/'
- * });
- * ```
- */
-export declare const createDatasource: (token: string, data: CreateDatasourceRequest, baseUrl?: string) => Promise<CreateDatasourceResponse>;
-/**
- * List all datasources for authenticated user.
- * Retrieves all datasource configurations accessible to the user.
- *
- * @param token - Authentication token
- * @param baseUrl - Base URL for IAM service
- * @returns List of datasources
- *
- * @example
- * ```typescript
- * const response = await listDatasources(token);
- * console.log(response.datasources);
- * ```
- */
-export declare const listDatasources: (token: string, baseUrl?: string) => Promise<ListDatasourcesResponse>;
-/**
- * Get a specific datasource by ID.
- * Retrieves detailed information about a specific datasource.
- *
- * @param token - Authentication token
- * @param datasourceId - Datasource unique identifier
- * @param baseUrl - Base URL for IAM service
- * @returns Datasource data
- *
- * @example
- * ```typescript
- * const response = await getDatasource(token, 'datasource-id-123');
- * console.log(response.datasource);
- * ```
- */
-export declare const getDatasource: (token: string, datasourceId: string, baseUrl?: string) => Promise<GetDatasourceResponse>;
-/**
- * Update a specific datasource.
- * Updates the configuration of an existing datasource.
- *
- * @param token - Authentication token
- * @param datasourceId - Datasource unique identifier
- * @param data - Update data
- * @param baseUrl - Base URL for IAM service
- * @returns Updated datasource data
- *
- * @example
- * ```typescript
- * const response = await updateDatasource(token, 'datasource-id-123', {
- *   description: 'Updated description',
- *   database: 'new_database'
- * });
- * ```
- */
-export declare const updateDatasource: (token: string, datasourceId: string, data: UpdateDatasourceRequest, baseUrl?: string) => Promise<UpdateDatasourceResponse>;
-/**
- * Delete a specific datasource.
- * Removes a datasource configuration.
- *
- * @param token - Authentication token
- * @param datasourceId - Datasource unique identifier
- * @param baseUrl - Base URL for IAM service
- *
- * @example
- * ```typescript
- * await deleteDatasource(token, 'datasource-id-123');
- * ```
- */
-export declare const deleteDatasource: (token: string, datasourceId: string, baseUrl?: string) => Promise<void>;

package/lib/api/iam/datasources.js

@@ -1,185 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/**
- * Datasources API functions.
- * @module api/iam/datasources
- */
-import { requestDatalayerAPI } from '../DatalayerApi.js';
-import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants.js';
-import { validateToken, validateRequiredString } from '../utils/validation.js';
-/**
- * Create a new datasource.
- * Creates a new datasource configuration for the authenticated user.
- *
- * @param token - Authentication token
- * @param data - Datasource creation data
- * @param baseUrl - Base URL for IAM service
- * @returns Created datasource data
- *
- * @example
- * ```typescript
- * const response = await createDatasource(token, {
- *   type: 'Amazon Athena',
- *   name: 'my-athena-datasource',
- *   description: 'Production Athena datasource',
- *   database: 'my_database',
- *   output_bucket: 's3://my-bucket/output/'
- * });
- * ```
- */
-export const createDatasource = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
-    validateToken(token);
-    validateRequiredString(data.name, 'Datasource name');
-    validateRequiredString(data.type, 'Datasource type');
-    // Map datasource type to API variant format
-    const variantMap = {
-        'Amazon Athena': 'athena',
-        'Google BigQuery': 'bigquery',
-        'Microsoft Sentinel': 'sentinel',
-        Splunk: 'splunk',
-    };
-    const requestBody = {
-        name: data.name,
-        variant: variantMap[data.type] || data.type.toLowerCase(),
-        description: data.description || '',
-        database: data.database || '',
-        outputBucket: data.output_bucket || '',
-    };
-    try {
-        return await requestDatalayerAPI({
-            url: `${baseUrl}${API_BASE_PATHS.IAM}/datasources`,
-            method: 'POST',
-            body: requestBody,
-            token,
-        });
-    }
-    catch (error) {
-        if (error.response?.status === 409) {
-            throw new Error(`Datasource with name '${data.name}' already exists. Please use a different name.`);
-        }
-        throw error;
-    }
-};
-/**
- * List all datasources for authenticated user.
- * Retrieves all datasource configurations accessible to the user.
- *
- * @param token - Authentication token
- * @param baseUrl - Base URL for IAM service
- * @returns List of datasources
- *
- * @example
- * ```typescript
- * const response = await listDatasources(token);
- * console.log(response.datasources);
- * ```
- */
-export const listDatasources = async (token, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
-    validateToken(token);
-    return await requestDatalayerAPI({
-        url: `${baseUrl}${API_BASE_PATHS.IAM}/datasources`,
-        method: 'GET',
-        token,
-    });
-};
-/**
- * Get a specific datasource by ID.
- * Retrieves detailed information about a specific datasource.
- *
- * @param token - Authentication token
- * @param datasourceId - Datasource unique identifier
- * @param baseUrl - Base URL for IAM service
- * @returns Datasource data
- *
- * @example
- * ```typescript
- * const response = await getDatasource(token, 'datasource-id-123');
- * console.log(response.datasource);
- * ```
- */
-export const getDatasource = async (token, datasourceId, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
-    validateToken(token);
-    validateRequiredString(datasourceId, 'Datasource ID');
-    try {
-        return await requestDatalayerAPI({
-            url: `${baseUrl}${API_BASE_PATHS.IAM}/datasources/${datasourceId}`,
-            method: 'GET',
-            token,
-        });
-    }
-    catch (error) {
-        if (error.response?.status === 404) {
-            throw new Error(`Datasource '${datasourceId}' not found.`);
-        }
-        throw error;
-    }
-};
-/**
- * Update a specific datasource.
- * Updates the configuration of an existing datasource.
- *
- * @param token - Authentication token
- * @param datasourceId - Datasource unique identifier
- * @param data - Update data
- * @param baseUrl - Base URL for IAM service
- * @returns Updated datasource data
- *
- * @example
- * ```typescript
- * const response = await updateDatasource(token, 'datasource-id-123', {
- *   description: 'Updated description',
- *   database: 'new_database'
- * });
- * ```
- */
-export const updateDatasource = async (token, datasourceId, data, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
-    validateToken(token);
-    validateRequiredString(datasourceId, 'Datasource ID');
-    const requestBody = { ...data };
-    try {
-        return await requestDatalayerAPI({
-            url: `${baseUrl}${API_BASE_PATHS.IAM}/datasources/${datasourceId}`,
-            method: 'PUT',
-            body: requestBody,
-            token,
-        });
-    }
-    catch (error) {
-        if (error.response?.status === 404) {
-            throw new Error(`Datasource '${datasourceId}' not found.`);
-        }
-        throw error;
-    }
-};
-/**
- * Delete a specific datasource.
- * Removes a datasource configuration.
- *
- * @param token - Authentication token
- * @param datasourceId - Datasource unique identifier
- * @param baseUrl - Base URL for IAM service
- *
- * @example
- * ```typescript
- * await deleteDatasource(token, 'datasource-id-123');
- * ```
- */
-export const deleteDatasource = async (token, datasourceId, baseUrl = DEFAULT_SERVICE_URLS.IAM) => {
-    validateToken(token);
-    validateRequiredString(datasourceId, 'Datasource ID');
-    try {
-        await requestDatalayerAPI({
-            url: `${baseUrl}${API_BASE_PATHS.IAM}/datasources/${datasourceId}`,
-            method: 'DELETE',
-            token,
-        });
-    }
-    catch (error) {
-        if (error.response?.status === 404) {
-            throw new Error(`Datasource '${datasourceId}' not found.`);
-        }
-        throw error;
-    }
-};

package/lib/components/toolbars/index.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/models/Datasource.d.ts

@@ -1,181 +0,0 @@
-export declare const asDatasource: (s: any) => IDatasource;
-export type IDatasourceVariant = 'athena' | 'bigquery' | 'mssentinel' | 'splunk';
-export type IDatasource = {
-    id: string;
-    variant: IDatasourceVariant;
-    name: string;
-    description: string;
-    database: string;
-    outputBucket: string;
-};
-export default IDatasource;
-import type { DatalayerCoreClient } from '../client';
-/**
- * Datasource type matching UI and API.
- */
-export type DatasourceType = 'Amazon Athena' | 'Google BigQuery' | 'Microsoft Sentinel' | 'Splunk';
-/**
- * Raw datasource data from API (snake_case with suffixes).
- */
-export interface DatasourceData {
-    /** Unique identifier (ULID) */
-    uid: string;
-    /** Datasource type */
-    type_s: DatasourceType;
-    /** Datasource name */
-    name_s: string;
-    /** Datasource description */
-    description_t: string;
-    /** Datasource variant (athena, bigquery, mssentinel, splunk) */
-    variant_s?: string;
-    /** Optional: Database name (required for Amazon Athena) */
-    database_s?: string;
-    /** Optional: S3 output bucket (required for Amazon Athena) */
-    output_bucket_s?: string;
-    /** Creation timestamp */
-    created_at?: string;
-    /** Last update timestamp */
-    updated_at?: string;
-}
-/**
- * Public JSON interface for Datasource (camelCase).
- */
-export interface DatasourceJSON {
-    /** Unique identifier */
-    uid: string;
-    /** Datasource type */
-    type: DatasourceType;
-    /** Datasource name */
-    name: string;
-    /** Datasource description */
-    description: string;
-    /** Optional: Database name */
-    database?: string;
-    /** Optional: S3 output bucket */
-    outputBucket?: string;
-    /** Creation timestamp */
-    createdAt?: Date;
-    /** Last update timestamp */
-    updatedAt?: Date;
-}
-/**
- * Request data for creating a new datasource.
- */
-export interface CreateDatasourceRequest {
-    /** Datasource type */
-    type: DatasourceType;
-    /** Datasource name (unique identifier) */
-    name: string;
-    /** Human-readable description */
-    description?: string;
-    /** Optional: Database name (required for Amazon Athena) */
-    database?: string;
-    /** Optional: S3 output bucket (required for Amazon Athena) */
-    output_bucket?: string;
-}
-/**
- * Request data for updating a datasource.
- */
-export interface UpdateDatasourceRequest {
-    /** Optional: update type */
-    type?: DatasourceType;
-    /** Optional: update name */
-    name?: string;
-    /** Optional: update description */
-    description?: string;
-    /** Optional: update database */
-    database?: string;
-    /** Optional: update output bucket */
-    output_bucket?: string;
-}
-/**
- * Response from creating a datasource.
- */
-export interface CreateDatasourceResponse {
-    success: boolean;
-    message: string;
-    datasource: DatasourceData;
-}
-/**
- * Response from getting a datasource.
- */
-export interface GetDatasourceResponse {
-    success: boolean;
-    message: string;
-    datasource: DatasourceData;
-}
-/**
- * Response from listing datasources.
- */
-export interface ListDatasourcesResponse {
-    success: boolean;
-    message: string;
-    datasources: DatasourceData[];
-}
-/**
- * Response from updating a datasource.
- */
-export interface UpdateDatasourceResponse {
-    success: boolean;
-    message: string;
-    datasource: DatasourceData;
-}
-/**
- * Datasource domain model for the Datalayer Client.
- * Provides state management and operations for datasources.
- *
- * @example
- * ```typescript
- * const datasource = await client.createDatasource({
- *   type: 'Amazon Athena',
- *   name: 'my-athena-datasource',
- *   description: 'Production Athena datasource',
- *   database: 'my_database',
- *   output_bucket: 's3://my-bucket/output/'
- * });
- *
- * await datasource.update({ description: 'Updated description' });
- * await datasource.delete();
- * ```
- */
-export declare class DatasourceDTO {
-    /** @internal */
-    _data: DatasourceData;
-    private _client;
-    private _deleted;
-    /**
-     * Create a Datasource instance.
-     * @param data - Datasource data from API
-     * @param client - Client instance
-     */
-    constructor(data: DatasourceData, client: DatalayerCoreClient);
-    private _checkDeleted;
-    get uid(): string;
-    get type(): DatasourceType;
-    get variant(): string | undefined;
-    get name(): string;
-    get description(): string;
-    get database(): string | undefined;
-    get outputBucket(): string | undefined;
-    get createdAt(): Date | undefined;
-    get updatedAt(): Date | undefined;
-    /**
-     * Update this datasource.
-     * @param updates - Fields to update
-     * @returns Updated Datasource instance
-     */
-    update(updates: UpdateDatasourceRequest): Promise<DatasourceDTO>;
-    /**
-     * Delete this datasource permanently.
-     */
-    delete(): Promise<void>;
-    /**
-     * Get datasource data in camelCase format.
-     */
-    toJSON(): DatasourceJSON;
-    /**
-     * Get raw datasource data exactly as received from API.
-     */
-    rawData(): DatasourceData;
-    toString(): string;
-}