@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/pro-serializer.js

@@ -0,0 +1,170 @@
+// Quote-and-escape a string for .pro CSV-like values: wrap in double quotes, double inner ".
+function quote(s) {
+    return `"${s.replace(/"/g, '""')}"`;
+}
+function paramTypeToInt(t) {
+    return t === "String" ? 2 : 1;
+}
+function variableTypeToInt(t) {
+    return t === "Numeric" ? 1 : 2;
+}
+function serializeParameters(params) {
+    if (params.length === 0)
+        return [];
+    const lines = [];
+    // 560 = parameter names
+    lines.push(`560,${params.length}`);
+    for (const p of params)
+        lines.push(p.name);
+    // 561 = parameter types (1=Numeric, 2=String)
+    lines.push(`561,${params.length}`);
+    for (const p of params)
+        lines.push(String(paramTypeToInt(p.type)));
+    // 590 = name,defaultValue (numbers raw, strings quoted)
+    lines.push(`590,${params.length}`);
+    for (const p of params) {
+        const dv = p.defaultValue;
+        const valStr = typeof dv === "number" ? String(dv) : quote(String(dv ?? ""));
+        lines.push(`${p.name},${valStr}`);
+    }
+    // 637 = name,prompt
+    lines.push(`637,${params.length}`);
+    for (const p of params)
+        lines.push(`${p.name},${quote(p.prompt ?? "")}`);
+    return lines;
+}
+function serializeVariables(vars) {
+    if (vars.length === 0)
+        return [];
+    const lines = [];
+    lines.push(`577,${vars.length}`);
+    for (const v of vars)
+        lines.push(v.name);
+    lines.push(`578,${vars.length}`);
+    for (const v of vars)
+        lines.push(String(variableTypeToInt(v.type)));
+    lines.push(`579,${vars.length}`);
+    for (const v of vars)
+        lines.push(String(v.position));
+    // 580/581 = start and end byte per variable. Zero everywhere for delimited
+    // sources; a fixed-width source is unusable without them.
+    lines.push(`580,${vars.length}`);
+    for (const v of vars)
+        lines.push(String(v.startByte ?? 0));
+    lines.push(`581,${vars.length}`);
+    for (const v of vars)
+        lines.push(String(v.endByte ?? 0));
+    return lines;
+}
+// 582 = per-column UI state, one entry per datasource column. Written verbatim:
+// the block counts COLUMNS, not variables, so its length legitimately exceeds
+// the variable count whenever columns are ignored.
+function serializeVariablesUIData(uiData) {
+    if (!uiData || uiData.length === 0)
+        return [];
+    return [`582,${uiData.length}`, ...uiData];
+}
+function serializeDataSource(ds) {
+    if (!ds || ds.type === "None")
+        return ["562,NULL"];
+    const REVERSE_TYPE_MAP = {
+        None: "NULL",
+        TM1CubeView: "VIEW",
+        TM1DimensionSubset: "SUBSET",
+        ASCII: "CHARACTERDELIMITED",
+        ODBC: "ODBC",
+        TM1Process: "TM1PROCESS",
+    };
+    const lines = [];
+    // A fixed-width ASCII source is its own .pro type, not a flag on the type.
+    const proType = ds.type === "ASCII" && ds.asciiDelimiterType === "FixedWidth"
+        ? "POSITIONDELIMITED"
+        : REVERSE_TYPE_MAP[ds.type];
+    lines.push(`562,${quote(proType)}`);
+    // 586 = DataSourceNameForServer, 585 = DataSourceNameForClient — this is the
+    // slot order TM1 itself writes; each falls back to the other when unset.
+    const server = ds.dataSourceNameForServer ?? ds.dataSourceNameForClient ?? "";
+    // TM1 leaves 585 empty when no client-side name is set — mirror that rather
+    // than duplicating the server name, which would alter state on re-import.
+    const client = ds.dataSourceNameForClient ?? "";
+    // TM1 leaves an unset slot bare ("585,"), it does not write empty quotes.
+    const slot = (s) => (s === "" ? "" : quote(s));
+    lines.push(`586,${slot(server)}`);
+    lines.push(`585,${slot(client)}`);
+    // View and subset names go in unquoted — TM1 writes `570,Ansicht, mit "Komma"`
+    // verbatim, commas and quotes included.
+    if (ds.type === "TM1CubeView") {
+        lines.push(`570,${ds.view ?? ""}`);
+    }
+    else if (ds.type === "TM1DimensionSubset") {
+        // 571 is the subset slot; 570 holds view names.
+        lines.push(`571,${ds.subset ?? ""}`);
+    }
+    else if (ds.type === "ASCII") {
+        if (ds.asciiDelimiterChar !== undefined)
+            lines.push(`567,${quote(ds.asciiDelimiterChar)}`);
+        if (ds.asciiQuoteCharacter !== undefined)
+            lines.push(`568,${quote(ds.asciiQuoteCharacter)}`);
+        if (ds.asciiHeaderRecords !== undefined)
+            lines.push(`569,${ds.asciiHeaderRecords}`);
+        if (ds.asciiDecimalSeparator !== undefined)
+            lines.push(`588,${quote(ds.asciiDecimalSeparator)}`);
+        if (ds.asciiThousandSeparator !== undefined)
+            lines.push(`589,${quote(ds.asciiThousandSeparator)}`);
+    }
+    else if (ds.type === "ODBC") {
+        if (ds.userName)
+            lines.push(`564,${quote(ds.userName)}`);
+        // 559 is the ODBC unicode-interface flag: `usesUnicode: true` → "559,1",
+        // false → "559,0". Measured on 11.8 by patching the property and reading
+        // the file back. TM1 writes the line for every source type, but only an
+        // ODBC source exposes it over REST, so only that branch can round-trip it.
+        if (ds.usesUnicode !== undefined)
+            lines.push(`559,${ds.usesUnicode ? 1 : 0}`);
+        // 565 is TM1's password slot. It is only filled when the caller explicitly
+        // exported credentials; the value is then what TM1's REST API returned —
+        // a server-bound ciphertext on v11, plain text on v12 — not TM1's own file
+        // encoding, so such a file is for round trips through this server, not for
+        // dropping into a data directory.
+        if (ds.password)
+            lines.push(`565,${quote(ds.password)}`);
+        // 566 is a counted block: header with the line count, then the SQL. TM1
+        // writes "566,0" when there is no query. The password (565) stays out —
+        // TM1 stores it as a server-encrypted blob, useless and unsafe to carry.
+        const queryLines = ds.query !== undefined && ds.query.length > 0
+            ? ds.query.split(/\r?\n/)
+            : [];
+        lines.push(`566,${queryLines.length}`);
+        lines.push(...queryLines);
+    }
+    return lines;
+}
+function serializeSection(code, body) {
+    const text = body ?? "";
+    const bodyLines = text.length > 0 ? text.split(/\r?\n/) : [];
+    // Line count in the header, like TM1: it keeps code that looks like a header
+    // line (e.g. a literal "930,0") inside the section on re-read.
+    return [`${code},${bodyLines.length}`, ...bodyLines];
+}
+// Serialize a TM1 process back to a .pro file body. Round-trip safe with parseProFile().
+// Line codes follow what TM1 writes itself (562/564/566/570/571/585/586, counted
+// sections), so files TM1 wrote parse back losslessly. Still omitted are the headers
+// TM1 adds but that carry no portable information: 601 (version), 565 (the
+// server-encrypted password blob), 592, 593-598, 599, 800/801, 928, 603. They are only
+// required when re-uploading via legacy TM1 .pro tooling, not for repo round-trip via
+// tm1_import_pro_file.
+export function serializeToPro(input) {
+    const lines = [];
+    lines.push(`602,${quote(input.name)}`);
+    lines.push(...serializeParameters(input.parameters ?? []));
+    lines.push(...serializeVariables(input.variables ?? []));
+    lines.push(...serializeVariablesUIData(input.variablesUIData));
+    lines.push(...serializeDataSource(input.dataSource));
+    lines.push(...serializeSection("572", input.prolog));
+    lines.push(...serializeSection("573", input.metadata));
+    lines.push(...serializeSection("574", input.data));
+    lines.push(...serializeSection("575", input.epilog));
+    // Trailing newline — TM1 .pro files end with one.
+    return lines.join("\n") + "\n";
+}
+//# sourceMappingURL=pro-serializer.js.map

package/dist/lib/process-parts-schema.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export declare const parameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+    }>;
+    defaultValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const variableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+    }>;
+    position: z.ZodNumber;
+    startByte: z.ZodOptional<z.ZodNumber>;
+    endByte: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const dataSourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        None: "None";
+        TM1CubeView: "TM1CubeView";
+        TM1DimensionSubset: "TM1DimensionSubset";
+        ASCII: "ASCII";
+        ODBC: "ODBC";
+        TM1Process: "TM1Process";
+    }>;
+    dataSourceNameForServer: z.ZodOptional<z.ZodString>;
+    dataSourceNameForClient: z.ZodOptional<z.ZodString>;
+    asciiDelimiterType: z.ZodOptional<z.ZodString>;
+    asciiDelimiterChar: z.ZodOptional<z.ZodString>;
+    asciiQuoteCharacter: z.ZodOptional<z.ZodString>;
+    asciiHeaderRecords: z.ZodOptional<z.ZodNumber>;
+    asciiDecimalSeparator: z.ZodOptional<z.ZodString>;
+    asciiThousandSeparator: z.ZodOptional<z.ZodString>;
+    usesUnicode: z.ZodOptional<z.ZodBoolean>;
+    userName: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodString>;
+    subset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=process-parts-schema.d.ts.map

package/dist/lib/process-parts-schema.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+// Shared Zod schemas for the deployable parts of a TI process (parameters,
+// variables, datasource). Used to validate untrusted input at two boundaries:
+//   - tm1_check_process_code tool input (already Zod-validated by the SDK)
+//   - parseProcessFromGit, which parses a user-authored {name}.json file
+// Keeping one definition prevents the git path from accepting shapes the tool
+// path would reject. Field names/shapes mirror ProcessParameter / ProcessVariable
+// / DataSource in ../types.ts — keep them in sync.
+export const parameterSchema = z.object({
+    name: z.string(),
+    type: z.enum(["String", "Numeric"]),
+    defaultValue: z.union([z.string(), z.number()]),
+    prompt: z.string().optional(),
+});
+export const variableSchema = z.object({
+    name: z.string(),
+    type: z.enum(["String", "Numeric"]),
+    position: z.number(),
+    startByte: z.number().optional(),
+    endByte: z.number().optional(),
+});
+export const dataSourceSchema = z.object({
+    type: z.enum([
+        "None",
+        "TM1CubeView",
+        "TM1DimensionSubset",
+        "ASCII",
+        "ODBC",
+        "TM1Process",
+    ]),
+    dataSourceNameForServer: z.string().optional(),
+    dataSourceNameForClient: z.string().optional(),
+    asciiDelimiterType: z.string().optional(),
+    asciiDelimiterChar: z.string().optional(),
+    asciiQuoteCharacter: z.string().optional(),
+    asciiHeaderRecords: z.number().optional(),
+    asciiDecimalSeparator: z.string().optional(),
+    asciiThousandSeparator: z.string().optional(),
+    usesUnicode: z.boolean().optional(),
+    userName: z.string().optional(),
+    password: z.string().optional(),
+    query: z.string().optional(),
+    view: z.string().optional(),
+    subset: z.string().optional(),
+});
+//# sourceMappingURL=process-parts-schema.js.map

package/dist/lib/process-refs.d.ts

@@ -0,0 +1,88 @@
+export declare const TABS: readonly ["prolog", "metadata", "data", "epilog"];
+export type Tab = (typeof TABS)[number];
+export type ProcessCode = Partial<Record<Tab, string>>;
+export interface RefIssue {
+    kind: "cube" | "dimension" | "element";
+    name: string;
+    /** For kind "element": the dimension it was looked up in. */
+    dimension?: string;
+    tab: Tab;
+    line: number;
+    context: string;
+}
+export interface ProcessRefReport {
+    cubeRefsScanned: number;
+    dimensionRefsScanned: number;
+    /** Distinct literal (dimension, element) pairs looked up. */
+    elementRefsScanned: number;
+    unresolved: number;
+    issues: RefIssue[];
+    /** Tabs that carried code and were scanned. */
+    tabsChecked: Tab[];
+    /**
+     * Object-name arguments passed as identifiers that no literal binding
+     * resolves (parameters, datasource variables, computed values). Those
+     * references were not checked.
+     */
+    unresolvableArgs: number;
+    /** True when unresolvableArgs > 0 — the report does not cover every reference. */
+    partial: boolean;
+}
+/** What the check needs from the server: the object catalogue. */
+export interface ObjectCatalogue {
+    cubes: {
+        list: () => Promise<Array<{
+            name: string;
+        }>>;
+        /** Needed for the element check; without it elements are not checked. */
+        getDimensionNames?: (cubeName: string) => Promise<string[]>;
+    };
+    dimensions: {
+        list: () => Promise<Array<{
+            name: string;
+        }>>;
+    };
+    elements?: {
+        exists: (dim: string, hierarchy: string, el: string) => Promise<boolean>;
+    };
+}
+type Found = Map<string, {
+    tab: Tab;
+    line: number;
+    context: string;
+}>;
+/** TM1 compares names ignoring case and spaces. */
+export declare const tm1Key: (s: string) => string;
+interface CellCall {
+    cube: string;
+    /** One entry per element argument: the literal, or null if not literal. */
+    elements: Array<string | null>;
+    tab: Tab;
+    line: number;
+    context: string;
+}
+interface Inserts {
+    /** tm1Key(dimension) → tm1Key(element) the code inserts. */
+    literal: Map<string, Set<string>>;
+    /** Dimensions the code inserts a computed element name into. */
+    dynamicDims: Set<string>;
+    /** True if some insert targets a dimension whose name is computed. */
+    dynamicAnyDim: boolean;
+}
+/** Parse-time half: collect the references, no server round-trip. */
+export declare function scanProcessRefs(code: ProcessCode): {
+    cubeRefs: Found;
+    dimRefs: Found;
+    createdCubes: Set<string>;
+    createdDims: Set<string>;
+    tabsChecked: Tab[];
+    unresolvableArgs: number;
+    cellCalls: CellCall[];
+    inserts: Inserts;
+};
+/** Scan the code and resolve every reference against the server's catalogue. */
+export declare function checkProcessRefs(catalogue: ObjectCatalogue, code: ProcessCode, opts?: {
+    includeControl?: boolean;
+}): Promise<ProcessRefReport>;
+export {};
+//# sourceMappingURL=process-refs.d.ts.map