@superblocksteam/sabs-client 0.419.0 → 0.423.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/sabs-client",
-  "version": "v0.419.0",
+  "version": "v0.423.0",
   "description": "Superblocks Application Build System Client for TypeScript",
   "repository": {
     "type": "git",
@@ -8,11 +8,16 @@
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
   "license": "Superblocks Community Software License",
   "dependencies": {
     "@superblocksteam/shared": "0.9543.7",
     "axios": "^1.8.3",
-    "@superblocksteam/sabs-types": "v0.419.0"
+    "@superblocksteam/sabs-types": "v0.423.0"
   },
   "devDependencies": {
     "@babel/preset-typescript": "^7.26.0",
@@ -44,7 +49,7 @@
     "node": ">=20.19.x"
   },
   "scripts": {
-    "build": "pnpm install && pnpm run lint:fix && tsc",
+    "build": "pnpm install && pnpm run lint:fix && pnpm exec tsc",
     "clean": "npx rimraf ./dist ./coverage *tsbuildinfo",
     "lint": "eslint . --ext ts --max-warnings 0 --cache --cache-strategy content --cache-location ~/.cache/eslint/",
     "lint:fix": "eslint . --ext ts --fix --cache --cache-strategy content --cache-location ~/.cache/eslint/",

package/.nvmrc

@@ -1 +0,0 @@
-20

package/.prettierignore

@@ -1,3 +0,0 @@
-./build
-./node_modules
-.github

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "semi": true,
-  "trailingComma": "none",
-  "singleQuote": true,
-  "tabWidth": 2,
-  "printWidth": 140,
-  "arrowParens": "always"
-}

package/eslint.config.mjs

@@ -1,261 +0,0 @@
-import { fixupConfigRules, fixupPluginRules } from '@eslint/compat';
-import { FlatCompat } from '@eslint/eslintrc';
-import js from '@eslint/js';
-import typescriptEslint from '@typescript-eslint/eslint-plugin';
-import tsParser from '@typescript-eslint/parser';
-import _import from 'eslint-plugin-import';
-import prettier from 'eslint-plugin-prettier';
-import globals from 'globals';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all
-});
-
-export default [
-  {
-    // Ignore Jest configuration file (it's excluded from tsconfig.json, so it's problematic!)
-    ignores: [
-      'coverage/*',
-      'dist/*',
-      'eslint.config.mjs',
-      '**/jest.config.js'
-    ]
-  },
-  ...fixupConfigRules(
-    compat.extends(
-      'eslint:recommended',
-      'plugin:@typescript-eslint/eslint-recommended',
-      'plugin:@typescript-eslint/recommended',
-      'plugin:@typescript-eslint/recommended-requiring-type-checking',
-      'plugin:import/typescript',
-      'prettier',
-      'plugin:prettier/recommended'
-    )
-  ),
-  {
-    plugins: {
-      '@typescript-eslint': fixupPluginRules(typescriptEslint),
-      import: fixupPluginRules(_import),
-      prettier: fixupPluginRules(prettier)
-    },
-
-    languageOptions: {
-      globals: {
-        ...globals.jest,
-        ...globals.node
-      },
-
-      parser: tsParser,
-      ecmaVersion: 2020,
-      sourceType: 'commonjs',
-
-      parserOptions: {
-        impliedStrict: true,
-        project: './**/tsconfig.json'
-      }
-    },
-
-    settings: {
-      'import/parsers': {
-        '@typescript-eslint/parser': ['.ts', '.tsx']
-      },
-
-      'import/resolver': {
-        node: {},
-
-        typescript: {
-          project: './**/tsconfig.json'
-        }
-      }
-    },
-
-    // Custom Configurations
-    rules: {
-      'prettier/prettier': ['error'],
-
-      '@typescript-eslint/array-type': [
-        'error',
-        {
-          default: 'array-simple',
-          readonly: 'array-simple'
-        }
-      ],
-
-      '@typescript-eslint/await-thenable': ['error'],
-      '@typescript-eslint/explicit-module-boundary-types': ['off'],
-      '@typescript-eslint/explicit-member-accessibility': ['error'],
-
-      '@typescript-eslint/member-ordering': [
-        'error',
-        {
-          default: ['static-field', 'static-method', 'instance-field', 'constructor', 'instance-method']
-        }
-      ],
-
-      '@typescript-eslint/no-empty-function': [
-        'error',
-        {
-          allow: ['constructors']
-        }
-      ],
-
-      '@typescript-eslint/no-floating-promises': ['error'],
-      '@typescript-eslint/no-for-in-array': ['error'],
-      '@typescript-eslint/no-misused-promises': ['error'],
-      '@typescript-eslint/no-require-imports': ['error'],
-      '@typescript-eslint/no-unsafe-assignment': ['off'],
-      '@typescript-eslint/no-unsafe-call': ['off'],
-      '@typescript-eslint/no-unsafe-member-access': ['off'],
-      '@typescript-eslint/no-unsafe-return': ['off'],
-
-      '@typescript-eslint/no-unused-vars': [
-        'error',
-        {
-          args: 'all',
-          argsIgnorePattern: '^_',
-          caughtErrors: 'all',
-          vars: 'all',
-          varsIgnorePattern: '^_'
-        }
-      ],
-
-      '@typescript-eslint/no-useless-constructor': ['error'],
-      '@typescript-eslint/prefer-for-of': ['error'],
-
-      '@typescript-eslint/prefer-nullish-coalescing': [
-        'error',
-        {
-          ignoreMixedLogicalExpressions: true
-        }
-      ],
-
-      '@typescript-eslint/prefer-readonly': ['error'],
-
-      '@typescript-eslint/promise-function-async': [
-        'error',
-        {
-          checkArrowFunctions: false
-        }
-      ],
-
-      '@typescript-eslint/restrict-template-expressions': [
-        'error',
-        {
-          allowNumber: true,
-          allowBoolean: true,
-          allowAny: true,
-          allowNullish: true
-        }
-      ],
-
-      '@typescript-eslint/require-await': ['error'],
-      '@typescript-eslint/return-await': ['error', 'in-try-catch'],
-      '@typescript-eslint/switch-exhaustiveness-check': ['error'],
-      complexity: ['off'],
-      'dot-notation': ['error'],
-
-      eqeqeq: [
-        'error',
-        'always',
-        {
-          null: 'ignore'
-        }
-      ],
-
-      'import/no-duplicates': ['error'],
-
-      'import/no-extraneous-dependencies': [
-        'error',
-        {
-          devDependencies: ['**/test/**', '**/*.test.ts'], // Only allow importing devDependencies from tests
-          optionalDependencies: false, // Disallow importing optional dependencies (those shouldn't be used here)
-          peerDependencies: false // Disallow importing peer dependencies (those shouldn't be used here)
-        }
-      ],
-
-      'import/no-unresolved': [
-        'error',
-        {
-          ignore: [
-            '@jsii/check-node/run', // @jsii/check-node uses an export map, which import/resolver does not (yet) support (https://github.com/import-js/eslint-plugin-import/issues/1868)
-            'worker_threads' // This isn't supported in all node versions (import is always guarded)
-          ]
-        }
-      ],
-
-      'import/order': [
-        'error',
-        {
-          alphabetize: {
-            order: 'asc',
-            caseInsensitive: true
-          },
-
-          groups: [
-            ['builtin', 'external'],
-            ['parent', 'sibling'],
-            ['index', 'unknown']
-          ],
-          'newlines-between': 'always'
-        }
-      ],
-
-      'no-alert': ['error'],
-      'no-await-in-loop': ['error'],
-      'no-caller': ['error'],
-
-      'no-else-return': [
-        'error',
-        {
-          allowElseIf: true
-        }
-      ],
-
-      'no-eval': ['error'],
-      'no-extra-bind': ['error'],
-      'no-implied-eval': ['error'],
-      'no-lone-blocks': ['error'],
-      'no-new-symbol': ['error'],
-      'no-proto': ['error'],
-
-      'no-restricted-properties': [
-        'error',
-        {
-          property: 'substr',
-          message: 'Use .slice instead of .substr.'
-        }
-      ],
-
-      'no-return-await': ['error'],
-      'no-unused-expressions': ['error'],
-      'no-useless-call': ['error'],
-      'no-var': ['error'],
-      'prefer-const': ['error'],
-      'prefer-template': ['error'],
-      'eol-last': ['error', 'always'],
-      // Disabled rules
-      '@typescript-eslint/explicit-function-return-type': 'off',
-      '@typescript-eslint/interface-name-prefix': 'off',
-      '@typescript-eslint/no-explicit-any': 'off',
-      '@typescript-eslint/no-non-null-assertion': 'off',
-      '@typescript-eslint/no-use-before-define': 'off',
-      '@typescript-eslint/unbound-method': 'off',
-      'no-case-declarations': 'off',
-      'require-atomic-updates': 'off',
-      // This is not a bad rule but it got sprung on us and our code loudly fails it
-      // Disable to get the eslint upgrade to pass.
-      '@typescript-eslint/no-unsafe-argument': 'off',
-      // 'consistent-return' actually decreases safety. Its use will enforce useless `throws`
-      // statements, forcing a runtime error that occlude cases where the TypeScript type
-      // checker would actually have caught something like a non-exhaustive `switch` statement
-      // at compile time.
-      'consistent-return': 'off'
-    }
-  }
-];

package/jest.config.js

@@ -1,13 +0,0 @@
-module.exports = {
-  roots: ['<rootDir>/'],
-  transform: {
-    '^.+\\.(ts|tsx)$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.test.json' }],
-  },
-  testRegex: '(/__tests__/.*|(\\.)(test|spec))\\.tsx?$',
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node', 'css'],
-  moduleDirectories: ['node_modules', 'src'],
-  transformIgnorePatterns: [],
-  modulePathIgnorePatterns: ['<rootDir>/dist/__mocks__/'],
-  collectCoverageFrom: ['src/**/*.ts', '!src/**/*.test.{js,jsx,ts,tsx}'],
-  testEnvironment: 'node'
-};

package/src/errors.test.ts

@@ -1,341 +0,0 @@
-import {
-  BadRequestError,
-  InternalServerError,
-  NotFoundError,
-  ConflictError,
-  UnauthorizedError,
-  ForbiddenError,
-  HttpError,
-  createErrorFromStatusCode,
-  createClientError,
-  createNetworkError
-} from './errors';
-
-describe('errors', () => {
-  describe('HttpError for unhandled status codes', () => {
-    test('creates error with correct properties', () => {
-      const status = 418;
-      const message = 'I am a teapot';
-
-      const error = new HttpError(status, message);
-
-      expect(error).toBeInstanceOf(Error);
-      expect(error).toBeInstanceOf(HttpError);
-      expect(error.name).toBe('Error');
-      expect(error.message).toBe(message);
-      expect(error.status).toBe(status);
-      expect(error.title).toBeUndefined(); // HttpError doesn't set title by default
-    });
-
-    test('has consistent interface with other error types', () => {
-      const error = new HttpError(422, 'Test message');
-
-      expect(error.message).toBe('Test message');
-      expect(error.status).toBe(422);
-
-      // Should have the same interface as other HttpError types
-      expect('status' in error).toBe(true);
-      expect('message' in error).toBe(true);
-    });
-
-    test('has proper stack trace', () => {
-      const error = new HttpError(500, 'Test error');
-      expect(error.stack).toBeDefined();
-      expect(error.stack).toContain('Test error');
-    });
-  });
-
-  describe('createErrorFromStatusCode', () => {
-    test('creates BadRequestError for status 400', () => {
-      const message = 'Invalid request';
-      const error = createErrorFromStatusCode(400, message);
-
-      expect(error).toBeInstanceOf(BadRequestError);
-      expect(error.message).toBe('SABS API Error (400): Invalid request');
-    });
-
-    test('creates UnauthorizedError for status 401', () => {
-      const message = 'Invalid credentials';
-      const error = createErrorFromStatusCode(401, message);
-
-      expect(error).toBeInstanceOf(UnauthorizedError);
-      expect(error.message).toBe('SABS API Error (401): Invalid credentials');
-    });
-
-    test('creates ForbiddenError for status 403', () => {
-      const message = 'Access denied';
-      const error = createErrorFromStatusCode(403, message);
-
-      expect(error).toBeInstanceOf(ForbiddenError);
-      expect(error.message).toBe('SABS API Error (403): Access denied');
-    });
-
-    test('creates NotFoundError for status 404', () => {
-      const message = 'Resource not found';
-      const error = createErrorFromStatusCode(404, message);
-
-      expect(error).toBeInstanceOf(NotFoundError);
-      expect(error.message).toBe('SABS API Error (404): Resource not found');
-    });
-
-    test('creates ConflictError for status 409', () => {
-      const message = 'Resource conflict';
-      const error = createErrorFromStatusCode(409, message);
-
-      expect(error).toBeInstanceOf(ConflictError);
-      expect(error.message).toBe('SABS API Error (409): Resource conflict');
-    });
-
-    test.each([500, 502, 503, 504])('creates InternalServerError for status %s', (statusCode) => {
-      const message = 'Server error';
-      const error = createErrorFromStatusCode(statusCode, message);
-
-      expect(error).toBeInstanceOf(InternalServerError);
-      expect(error.message).toBe(`SABS API Error (${statusCode}): Server error`);
-    });
-
-    test('creates HttpError for unhandled status codes', () => {
-      const statusCode = 418; // I'm a teapot
-      const message = 'Teapot error';
-
-      const error = createErrorFromStatusCode(statusCode, message);
-
-      expect(error).toBeInstanceOf(HttpError);
-      expect(error.message).toBe('SABS API Error (418): Teapot error');
-
-      if (error instanceof HttpError) {
-        expect(error.status).toBe(statusCode);
-      }
-    });
-
-    test('handles edge case status codes', () => {
-      // Test some edge cases
-      const testCases = [
-        { status: 100, expected: HttpError },
-        { status: 200, expected: HttpError },
-        { status: 300, expected: HttpError },
-        { status: 451, expected: HttpError }, // Unavailable For Legal Reasons
-        { status: 999, expected: HttpError }
-      ];
-
-      testCases.forEach(({ status, expected }) => {
-        const error = createErrorFromStatusCode(status, 'Test message');
-        expect(error).toBeInstanceOf(expected);
-      });
-    });
-
-    test('all error types have consistent HttpError interface', () => {
-      const testCases = [
-        { statusCode: 400, expectedType: BadRequestError, expectedTitle: 'Bad request' },
-        { statusCode: 500, expectedType: InternalServerError, expectedTitle: 'Internal server error' },
-        { statusCode: 418, expectedType: HttpError, expectedTitle: undefined }
-      ];
-
-      testCases.forEach(({ statusCode, expectedType, expectedTitle }) => {
-        const error = createErrorFromStatusCode(statusCode, 'Test message');
-
-        expect(error).toBeInstanceOf(expectedType);
-        expect(error.message).toBe(`SABS API Error (${statusCode}): Test message`);
-
-        // All error types should have consistent HttpError interface
-        expect('status' in error).toBe(true);
-        if ('status' in error) {
-          expect(error.status).toBe(statusCode);
-        }
-        if ('title' in error) {
-          expect(error.title).toBe(expectedTitle);
-        }
-      });
-    });
-
-    test('returns standard error types for known status codes', () => {
-      const testCases = [
-        { status: 400, expectedType: BadRequestError },
-        { status: 401, expectedType: UnauthorizedError },
-        { status: 403, expectedType: ForbiddenError },
-        { status: 404, expectedType: NotFoundError },
-        { status: 409, expectedType: ConflictError },
-        { status: 500, expectedType: InternalServerError },
-        { status: 502, expectedType: InternalServerError },
-        { status: 503, expectedType: InternalServerError },
-        { status: 504, expectedType: InternalServerError }
-      ];
-
-      testCases.forEach(({ status, expectedType }) => {
-        const error = createErrorFromStatusCode(status, 'Test message');
-
-        expect(error).toBeInstanceOf(Error);
-        expect(error).toBeInstanceOf(expectedType);
-        expect(error.name).toBe('Error'); // Shared library errors use 'Error' as name
-        expect(error.message).toBe(`SABS API Error (${status}): Test message`);
-      });
-    });
-  });
-
-  describe('createClientError', () => {
-    test('creates BadRequestError with client error prefix', () => {
-      const message = 'Missing required parameter';
-      const error = createClientError(message);
-
-      expect(error).toBeInstanceOf(BadRequestError);
-      expect(error.message).toBe('SABS Client Error: Missing required parameter');
-    });
-
-    test('handles empty message', () => {
-      const error = createClientError('');
-      expect(error.message).toBe('SABS Client Error: ');
-    });
-
-    test('handles special characters in message', () => {
-      const message = 'Invalid characters: <>&"\'';
-      const error = createClientError(message);
-      expect(error.message).toBe(`SABS Client Error: ${message}`);
-    });
-  });
-
-  describe('createNetworkError', () => {
-    test('creates InternalServerError with network error prefix', () => {
-      const message = 'Connection refused';
-      const error = createNetworkError(message);
-
-      expect(error).toBeInstanceOf(InternalServerError);
-      expect(error.message).toBe('SABS Network Error: Connection refused');
-    });
-
-    test('includes original error message when provided', () => {
-      const message = 'Request failed';
-      const originalError = new Error('ECONNREFUSED');
-      const error = createNetworkError(message, originalError);
-
-      expect(error).toBeInstanceOf(InternalServerError);
-      expect(error.message).toBe('SABS Network Error: Request failed (caused by: ECONNREFUSED)');
-    });
-
-    test('handles original error without message', () => {
-      const message = 'Network issue';
-      const originalError = new Error(); // Empty message
-      const error = createNetworkError(message, originalError);
-
-      expect(error.message).toBe('SABS Network Error: Network issue (caused by: )');
-    });
-
-    test('handles null original error', () => {
-      const message = 'Unknown network error';
-      const error = createNetworkError(message, undefined);
-
-      expect(error.message).toBe('SABS Network Error: Unknown network error');
-    });
-  });
-
-  describe('error inheritance and instanceof checks', () => {
-    test('all error types are instances of Error', () => {
-      const errors = [
-        createErrorFromStatusCode(400, 'Bad Request'),
-        createErrorFromStatusCode(401, 'Unauthorized'),
-        createErrorFromStatusCode(403, 'Forbidden'),
-        createErrorFromStatusCode(404, 'Not Found'),
-        createErrorFromStatusCode(409, 'Conflict'),
-        createErrorFromStatusCode(500, 'Internal Server Error'),
-        createErrorFromStatusCode(418, 'Teapot'),
-        createClientError('Client error'),
-        createNetworkError('Network error'),
-        new HttpError(422, 'Custom error')
-      ];
-
-      errors.forEach((error) => {
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toBeDefined();
-        expect(typeof error.message).toBe('string');
-        expect(error.name).toBeDefined();
-      });
-    });
-
-    test('error types can be distinguished via instanceof', () => {
-      const badRequestError = createErrorFromStatusCode(400, 'Bad Request');
-      const unauthorizedError = createErrorFromStatusCode(401, 'Unauthorized');
-      const notFoundError = createErrorFromStatusCode(404, 'Not Found');
-      const httpError = createErrorFromStatusCode(418, 'Teapot');
-
-      // All errors extend HttpError, so they're all instances of HttpError
-      expect(badRequestError).toBeInstanceOf(BadRequestError);
-      expect(badRequestError).toBeInstanceOf(HttpError);
-      expect(badRequestError).not.toBeInstanceOf(UnauthorizedError);
-
-      expect(unauthorizedError).toBeInstanceOf(UnauthorizedError);
-      expect(unauthorizedError).toBeInstanceOf(HttpError);
-      expect(unauthorizedError).not.toBeInstanceOf(BadRequestError);
-
-      expect(notFoundError).toBeInstanceOf(NotFoundError);
-      expect(notFoundError).toBeInstanceOf(HttpError);
-      expect(notFoundError).not.toBeInstanceOf(BadRequestError);
-
-      expect(httpError).toBeInstanceOf(HttpError);
-      expect(httpError).not.toBeInstanceOf(BadRequestError);
-    });
-  });
-
-  describe('error serialization and JSON handling', () => {
-    test('errors can be converted to JSON for logging', () => {
-      const error = new HttpError(422, 'Test error');
-
-      // Test that error properties are accessible for logging
-      const logObject = {
-        message: error.message,
-        name: error.name,
-        status: error.status,
-        title: error.title
-      };
-
-      expect(logObject.message).toBe('Test error');
-      expect(logObject.name).toBe('Error');
-      expect(logObject.status).toBe(422);
-      expect(logObject.title).toBeUndefined();
-    });
-
-    test('shared error types have basic error properties', () => {
-      const error = createErrorFromStatusCode(400, 'Validation failed');
-
-      const logObject = {
-        message: error.message,
-        name: error.name,
-        stack: error.stack
-      };
-
-      expect(logObject.message).toBe('SABS API Error (400): Validation failed');
-      expect(logObject.name).toBeDefined();
-      expect(logObject.stack).toBeDefined();
-    });
-  });
-
-  describe('edge cases and error conditions', () => {
-    test('handles undefined and null inputs gracefully', () => {
-      // These should not throw, but create errors with undefined/null content
-      expect(() => createErrorFromStatusCode(400, undefined as any)).not.toThrow();
-      expect(() => createErrorFromStatusCode(400, null as any)).not.toThrow();
-      expect(() => createClientError(undefined as any)).not.toThrow();
-      expect(() => createNetworkError(undefined as any)).not.toThrow();
-    });
-
-    test('handles very large status codes', () => {
-      const error = createErrorFromStatusCode(999999, 'Large status code');
-      expect(error).toBeInstanceOf(HttpError);
-      if (error instanceof HttpError) {
-        expect(error.status).toBe(999999);
-      }
-    });
-
-    test('handles negative status codes', () => {
-      const error = createErrorFromStatusCode(-1, 'Negative status code');
-      expect(error).toBeInstanceOf(HttpError);
-      if (error instanceof HttpError) {
-        expect(error.status).toBe(-1);
-      }
-    });
-
-    test('handles very long error messages', () => {
-      const longMessage = 'x'.repeat(10000);
-      const error = createErrorFromStatusCode(400, longMessage);
-      expect(error.message).toContain(longMessage);
-    });
-  });
-});