infrahub-sdk 0.0.1

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/auth.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/error-handling.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/validation.js

@@ -0,0 +1 @@
+"use strict";

package/eslint.config.mjs

@@ -0,0 +1,9 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+);

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "infrahub-sdk",
+  "version": "0.0.1",
+  "description": "A client SDK for the Infrahub API.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --config=jest.config.js --runInBand",
+    "format": "prettier --write \"src/**/*.{ts,js,json}\"",
+    "lint": "eslint --ext .ts,.js src"
+  },
+  "keywords": [
+    "sdk",
+    "infrahub"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "graphql-request": "^6.1.0",
+    "openapi-fetch": "^0.9.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.31.0",
+    "eslint": "^9.31.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "prettier": "3.6.2",
+    "ts-jest": "^29.4.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.37.0"
+  }
+}

package/src/branch.ts

@@ -0,0 +1,161 @@
+import { InfrahubClient, gql } from './index';
+import { Mutation } from './graphql';
+
+interface Branch {
+  id: string;
+  name: string;
+  description: string;
+  origin_branch: string;
+  branched_from: string;
+  is_default: boolean;
+  sync_with_git: boolean;
+  has_schema_changes: boolean;
+}
+
+export interface BranchCreateInput {
+  name: string;
+  description?: string;
+  sync_with_git?: boolean;
+  wait_until_completion?: boolean;
+}
+
+export class BranchNotFoundError extends Error {
+  constructor(identifier: string) {
+    super(`Branch not found: ${identifier}`);
+    this.name = 'BranchNotFoundError';
+  }
+}
+
+const MUTATION_QUERY_TASK = { ok: null, task: { id: null } };
+const MUTATION_QUERY_DATA = {
+  ok: null,
+  object: {
+    id: null,
+    name: null,
+    description: null,
+    origin_branch: null,
+    branched_from: null,
+    is_default: null,
+    sync_with_git: null,
+    has_schema_changes: null
+  }
+};
+
+// InfrahubBranchManager class to manage branches via GraphQL
+export class InfrahubBranchManager {
+  private client: InfrahubClient;
+
+  constructor(client: InfrahubClient) {
+    this.client = client;
+  }
+
+  /**
+   * Fetches all branches using GraphQL and returns an object mapping branch names to branch data.
+   */
+  async all(): Promise<Record<string, Branch>> {
+    const query = gql`
+      query BranchQuery {
+        Branch {
+          id
+          name
+          description
+          origin_branch
+          branched_from
+          is_default
+          sync_with_git
+          has_schema_changes
+        }
+      }
+    `;
+    const response = await this.client.executeGraphQL(query);
+    const branches: Branch[] = response.Branch || [];
+    const result: Record<string, Branch> = {};
+    for (const branch of branches) {
+      result[branch.name] = branch;
+    }
+    return result;
+  }
+
+  /**
+   * Fetches a specific branch by name.
+   * @param branchName The name of the branch to fetch.
+   */
+  async get(branchName: string): Promise<Branch | null> {
+    const query = gql`
+      query BranchQuery($name: String!) {
+        Branch(name: $name) {
+          id
+          name
+          description
+          origin_branch
+          branched_from
+          is_default
+          sync_with_git
+          has_schema_changes
+        }
+      }
+    `;
+    const response = await this.client.executeGraphQL(query, {
+      name: branchName
+    });
+    const branchArr: Branch[] = response.Branch || [];
+    if (!branchArr.length) {
+      throw new BranchNotFoundError(branchName);
+    }
+    return branchArr[0];
+  }
+
+  async create(input: BranchCreateInput): Promise<Branch> {
+    const inputData = {
+      background_execution: input.wait_until_completion,
+      data: {
+        name: input.name,
+        description: input.description,
+        sync_with_git: input.sync_with_git
+      }
+    };
+
+    // set mutation query to MUTATION_QUERY_TASK if brackground_execution is true
+    const mutationQuery = input.wait_until_completion
+      ? MUTATION_QUERY_TASK
+      : MUTATION_QUERY_DATA;
+
+    const mutation = new Mutation({
+      mutation: 'BranchCreate',
+      inputData: inputData,
+      query: mutationQuery,
+      name: 'CreateBranch'
+    });
+    // You may want to remove this log in production
+    console.log(mutation.render());
+    const response = await this.client.executeGraphQL(mutation.render(), {
+      input: inputData
+    });
+    // Adjust the response path as needed based on your API
+    const branchData =
+      response.BranchCreate?.object || response.BranchCreate?.task || null;
+    if (!branchData) {
+      throw new Error('Branch creation failed');
+    }
+    return branchData as Branch;
+  }
+
+  async delete(branchName: string): Promise<boolean> {
+    const inputData = {
+      data: {
+        name: branchName
+      }
+    };
+    const mutation = new Mutation({
+      mutation: 'BranchDelete',
+      inputData: inputData,
+      query: { ok: null },
+      name: 'DeleteBranch'
+    });
+    const response = await this.client.executeGraphQL(mutation.render(), {
+      input: inputData
+    });
+    console.log(response);
+    return !!(response.BranchDelete && response.BranchDelete.ok);
+  }
+}

package/src/graphql.ts

@@ -0,0 +1,266 @@
+export type VariableType =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | VariableType[]
+  | Record<string, any>;
+
+export function convertToGraphqlAsString(
+  value: VariableType,
+  convertEnum: boolean = false
+): string {
+  if (typeof value === 'string' && value.startsWith('$')) {
+    return value;
+  }
+  if (
+    typeof value === 'object' &&
+    value &&
+    'constructor' in value &&
+    value.constructor.name === 'Enum'
+  ) {
+    // TypeScript enums are not runtime objects, so you may need to handle this differently
+    return convertEnum
+      ? convertToGraphqlAsString((value as any).value, true)
+      : (value as any).name;
+  }
+  if (typeof value === 'string') {
+    return `"${value}"`;
+  }
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+  if (Array.isArray(value)) {
+    const valuesAsString = value.map((item) =>
+      convertToGraphqlAsString(item, convertEnum)
+    );
+    return `[${valuesAsString.join(', ')}]`;
+  }
+  if (typeof value === 'object' && value !== null) {
+    const entries = Object.entries(value).map(
+      ([key, val]) => `${key}: ${convertToGraphqlAsString(val, convertEnum)}`
+    );
+    return `{ ${entries.join(', ')} }`;
+  }
+  return String(value);
+}
+
+const VARIABLE_TYPE_MAPPING: [any, string][] = [
+  [String, 'String!'],
+  [Number, 'Int!'],
+  [Boolean, 'Boolean!']
+];
+
+export function renderVariablesToString(data: Record<string, any>): string {
+  const varsDict: Record<string, string> = {};
+  for (const [key, value] of Object.entries(data)) {
+    for (const [classType, varString] of VARIABLE_TYPE_MAPPING) {
+      if (value === classType) {
+        varsDict[`$${key}`] = varString;
+      }
+    }
+  }
+  return Object.entries(varsDict)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(', ');
+}
+
+export function renderQueryBlock(
+  data: Record<string, any>,
+  offset: number = 4,
+  indentation: number = 4,
+  convertEnum: boolean = false
+): string[] {
+  const FILTERS_KEY = '@filters';
+  const ALIAS_KEY = '@alias';
+  const KEYWORDS_TO_SKIP = [FILTERS_KEY, ALIAS_KEY];
+
+  const offsetStr = ' '.repeat(offset);
+  const lines: string[] = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (KEYWORDS_TO_SKIP.includes(key)) continue;
+    if (value === null || value === undefined) {
+      lines.push(`${offsetStr}${key}`);
+    } else if (
+      typeof value === 'object' &&
+      value !== null &&
+      Object.keys(value).length === 1 &&
+      value[ALIAS_KEY]
+    ) {
+      lines.push(`${offsetStr}${value[ALIAS_KEY]}: ${key}`);
+    } else if (typeof value === 'object' && value !== null) {
+      const keyStr = value[ALIAS_KEY] ? `${value[ALIAS_KEY]}: ${key}` : key;
+      if (value[FILTERS_KEY]) {
+        const filtersStr = Object.entries(value[FILTERS_KEY])
+          .map(
+            ([k2, v2]) =>
+              `${k2}: ${convertToGraphqlAsString(v2 as VariableType, convertEnum)}`
+          )
+          .join(', ');
+        lines.push(`${offsetStr}${keyStr}(${filtersStr}) {`);
+      } else {
+        lines.push(`${offsetStr}${keyStr} {`);
+      }
+      lines.push(
+        ...renderQueryBlock(
+          value,
+          offset + indentation,
+          indentation,
+          convertEnum
+        )
+      );
+      lines.push(offsetStr + '}');
+    } else {
+      lines.push(`${offsetStr}${key}`);
+    }
+  }
+  return lines;
+}
+
+export function renderInputBlock(
+  data: Record<string, any>,
+  offset: number = 4,
+  indentation: number = 4,
+  convertEnum: boolean = false
+): string[] {
+  const offsetStr = ' '.repeat(offset);
+  const lines: string[] = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      lines.push(`${offsetStr}${key}: {`);
+      lines.push(
+        ...renderInputBlock(
+          value,
+          offset + indentation,
+          indentation,
+          convertEnum
+        )
+      );
+      lines.push(offsetStr + '}');
+    } else if (Array.isArray(value)) {
+      lines.push(`${offsetStr}${key}: [`);
+      for (const item of value) {
+        if (typeof item === 'object' && item !== null) {
+          lines.push(`${offsetStr}${' '.repeat(indentation)}{`);
+          lines.push(
+            ...renderInputBlock(
+              item,
+              offset + indentation * 2,
+              indentation,
+              convertEnum
+            )
+          );
+          lines.push(`${offsetStr}${' '.repeat(indentation)}},`);
+        } else {
+          lines.push(
+            `${offsetStr}${' '.repeat(indentation)}${convertToGraphqlAsString(item, convertEnum)},`
+          );
+        }
+      }
+      lines.push(offsetStr + ']');
+    } else {
+      lines.push(
+        `${offsetStr}${key}: ${convertToGraphqlAsString(value, convertEnum)}`
+      );
+    }
+  }
+  return lines;
+}
+
+export class BaseGraphQLQuery {
+  queryType: string = 'not-defined';
+  indentation: number = 4;
+  query: Record<string, any>;
+  variables?: Record<string, any>;
+  name: string;
+
+  constructor(
+    query: Record<string, any>,
+    variables?: Record<string, any>,
+    name?: string
+  ) {
+    this.query = query;
+    this.variables = variables;
+    this.name = name || '';
+  }
+
+  renderFirstLine(): string {
+    let firstLine = this.queryType;
+    if (this.name) {
+      firstLine += ' ' + this.name;
+    }
+    if (this.variables) {
+      firstLine += ` (${renderVariablesToString(this.variables)})`;
+    }
+    firstLine += ' {';
+    return firstLine;
+  }
+}
+
+export class Query extends BaseGraphQLQuery {
+  queryType = 'query';
+
+  render(convertEnum: boolean = false): string {
+    const lines: string[] = [this.renderFirstLine()];
+    lines.push(
+      ...renderQueryBlock(
+        this.query,
+        this.indentation,
+        this.indentation,
+        convertEnum
+      )
+    );
+    lines.push('}');
+    return '\n' + lines.join('\n') + '\n';
+  }
+}
+
+export class Mutation extends BaseGraphQLQuery {
+  queryType = 'mutation';
+  inputData: Record<string, any>;
+  mutation: string;
+
+  constructor({
+    mutation,
+    inputData,
+    query,
+    variables,
+    name
+  }: {
+    mutation: string;
+    inputData: Record<string, any>;
+    query: Record<string, any>;
+    variables?: Record<string, any>;
+    name?: string;
+  }) {
+    super(query, variables, name);
+    this.inputData = inputData;
+    this.mutation = mutation;
+  }
+
+  render(convertEnum: boolean = false): string {
+    const lines: string[] = [this.renderFirstLine()];
+    lines.push(' '.repeat(this.indentation) + `${this.mutation}(`);
+    lines.push(
+      ...renderInputBlock(
+        this.inputData,
+        this.indentation,
+        this.indentation * 2,
+        convertEnum
+      )
+    );
+    lines.push(' '.repeat(this.indentation) + '){');
+    lines.push(
+      ...renderQueryBlock(
+        this.query,
+        this.indentation,
+        this.indentation * 2,
+        convertEnum
+      )
+    );
+    lines.push(' '.repeat(this.indentation) + '}');
+    lines.push('}');
+    return '\n' + lines.join('\n') + '\n';
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,74 @@
+import { InfrahubClient, InfrahubClientOptions } from './index';
+import { GraphQLClient } from 'graphql-request';
+// Import expect for type checking and editor support
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+describe('InfrahubClient', () => {
+  const baseURL = 'https://example.com';
+  const token = 'test-token';
+  let client: InfrahubClient;
+
+  // Initialize the client before each test
+
+  beforeEach(() => {
+    const options: InfrahubClientOptions = {
+      address: baseURL,
+      token: token
+    };
+    client = new InfrahubClient(options);
+  });
+
+  it('should initialize with baseURL and token', () => {
+    expect((client as any).baseUrl).toBe(baseURL);
+    expect((client as any).token).toBe(token);
+  });
+
+  it('should set auth token and update GraphQL headers', () => {
+    const newToken = 'new-token';
+    client.setAuthToken(newToken);
+    expect((client as any).token).toBe(newToken);
+    // GraphQLClient headers are private, so we check no error is thrown
+    expect(() => client.executeGraphQL('{ __typename }')).not.toThrow();
+  });
+
+  it('should call graphqlQuery and handle errors', async () => {
+    const mockRequest = jest
+      .fn()
+      .mockImplementationOnce(() => Promise.reject(new Error('GraphQL error')));
+    (client as any).graphqlClient.request = mockRequest;
+    const consoleErrorSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+    await expect(client.executeGraphQL('{ test }')).rejects.toThrow(
+      'GraphQL error'
+    );
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should initialize rest client with baseUrl', () => {
+    expect((client as any).rest).toBeDefined();
+  });
+
+  it('should have a GraphQL client initialized', () => {
+    expect((client as any).graphqlClient).toBeInstanceOf(GraphQLClient);
+  });
+
+  it('should have a rest client initialized', () => {
+    expect((client as any).rest).toBeDefined();
+  });
+
+  it('should have a default branch set', () => {
+    expect((client as any).defaultBranch).toBe('main');
+  });
+
+  it('should have a graphqlUrl method that returns the correct URL', () => {
+    const url = (client as any)._graphqlUrl();
+    expect(url).toBe(`${baseURL}/graphql/main`);
+  });
+
+  it('graphqlUrl should return the correct URL for a specific branch', () => {
+    const branchName = 'test-branch';
+    const url = (client as any)._graphqlUrl(branchName);
+    expect(url).toBe(`${baseURL}/graphql/${branchName}`);
+  });
+});