@bagelink/sdk 1.20.54 → 1.20.56

package/src/openAPITools/typeGenerator.js

@@ -0,0 +1,48 @@
+import { isSchemaObject } from './types/utils';
+import { formatType, formatVarType, schemaToType } from './utils';
+export function generateTypes(schemas) {
+    if (!schemas) {
+        return '';
+    }
+    const schemaEntries = Object.entries(schemas);
+    return schemaEntries
+        .map(([_typeName, schema]) => {
+        const typeName = formatType(_typeName);
+        if (!isSchemaObject(schema)) {
+            return '';
+        }
+        if (schema?.enum) {
+            return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(' | ')};\n`;
+        }
+        if (schema?.type === 'array' && schema.items) {
+            return `export type ${typeName} = (${schemaToType(schema.items)})[];\n`;
+        }
+        if (!schema.properties) {
+            // Handle case where schema has additionalProperties: true
+            if (schema.additionalProperties === true) {
+                return `export type ${typeName} = { [key: string]: any };\n`;
+            }
+            // #region Debug
+            // console.log('No properties found for schema:', typeName)
+            // console.log(JSON.stringify({ typeName, schema }, null, 2))
+            // #endregion Debug
+            return '';
+        }
+        // Handle empty properties with additionalProperties
+        if (Object.keys(schema.properties).length === 0 && schema.additionalProperties === true) {
+            return `export type ${typeName} = { [key: string]: any };\n`;
+        }
+        const properties = Object.entries(schema.properties)
+            .map(([key, value]) => {
+            // Wrap key in quotes if it contains hyphens or isn't a valid identifier
+            const quotedKey = /^[a-z_$][\w$]*$/i.test(key) ? key : `'${key}'`;
+            const varType = formatVarType({ varName: quotedKey, schema: value });
+            return `\t\t${varType}`;
+        })
+            .join(';\n ');
+        // Add index signature for additionalProperties if true
+        const indexSignature = schema.additionalProperties === true ? '\n\t\t[key: string]: any;' : '';
+        return `export type ${typeName} = {\n ${properties};${indexSignature}\n };\n`;
+    })
+        .join('\n');
+}

package/src/openAPITools/types/index.js

@@ -0,0 +1,19 @@
+// Typed interfaces for OpenAPI 3.1.0
+// see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
+const TYPE_FORMATS = [
+    'uuid',
+    'uri',
+    'date-time',
+    'date',
+    'email',
+    'binary',
+    'password',
+    'phone',
+    'uuid4',
+    'int32',
+    'int64',
+    'float',
+    'double',
+    'byte'
+];
+export * from './utils';

package/src/openAPITools/types/utils.js

@@ -0,0 +1,30 @@
+export function getPath(pathsObject, path) {
+    return pathsObject ? pathsObject[path] : undefined;
+}
+/**
+ * A type guard to check if the given value is a `ReferenceObject`.
+ * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-differentiating-types
+ *
+ * @param obj The value to check.
+ */
+export function isReferenceObject(obj) {
+    if (!obj) {
+        return false;
+    }
+    return Object.hasOwn(obj, '$ref');
+}
+/**
+ * A type guard to check if the given object is a `SchemaObject`.
+ * Useful to distinguish from `ReferenceObject` values that can be used
+ * in most places where `SchemaObject` is allowed.
+ *
+ * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-differentiating-types
+ *
+ * @param schema The value to check.
+ */
+export function isSchemaObject(schema) {
+    return !Object.hasOwn(schema, '$ref');
+}
+export function dereference(property) {
+    return property;
+}

package/src/openAPITools/utils.js

@@ -0,0 +1,282 @@
+import { isReferenceObject, isSchemaObject } from './types/utils';
+export function toCamelCase(str) {
+    return str
+        ?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '')
+        .replace(/^./, str => str.toLowerCase())
+        || str
+        || '';
+}
+export function toPascalCase(str) {
+    return str
+        ?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '')
+        .replace(/^./, str => str.toUpperCase())
+        || str
+        || '';
+}
+export function formatType(typeName) {
+    typeName = typeName
+        .replaceAll('-', '')
+        .replaceAll(/post|put$/gi, '')
+        .replaceAll(/^body_/gi, '');
+    return toPascalCase(typeName);
+}
+function resolveReference(ref) {
+    const t = ref.split('/').pop();
+    if (!t) {
+        return 'any';
+    }
+    return formatType(t);
+}
+function handleArrayItems(schema) {
+    // Handle array items that might be union types
+    const itemType = schemaToType(schema.items);
+    // Add parentheses around union types to ensure correct syntax
+    const needsParentheses = itemType.includes('|') || itemType.includes('&');
+    let res = needsParentheses ? `(${itemType})[]` : `${itemType}[]`;
+    if (itemType.includes('string | string')) {
+        res = res.replace('string | string', 'string');
+    }
+    if (itemType.includes('string |')) {
+        return res.replace('string |', '(string & {}) |');
+    }
+    if (itemType.includes('| string')) {
+        return res.replace('| string', '| (string & {})');
+    }
+    return res;
+}
+export function schemaToType(schema) {
+    if (!schema) {
+        return 'any';
+    }
+    if (isReferenceObject(schema)) {
+        if (schema.$ref) {
+            return resolveReference(schema.$ref);
+        }
+    }
+    if (!isSchemaObject(schema)) {
+        console.warn('Schema is not a SchemaObject:', schema);
+        return 'any';
+    }
+    if (schema.anyOf) {
+        let _t = schema.anyOf
+            .map(s => schemaToType(s))
+            .filter(p => p !== 'any')
+            .join(' | ');
+        if (_t === '' || _t === 'null') {
+            _t = 'any';
+        }
+        return _t;
+    }
+    if (schema.oneOf) {
+        let _t = schema.oneOf
+            .map(s => schemaToType(s))
+            .filter(p => p !== 'any')
+            .join(' | ');
+        if (_t === '' || _t === 'null') {
+            _t = 'any';
+        }
+        return _t;
+    }
+    if (schema.allOf) {
+        return schema.allOf
+            .map(s => schemaToType(s))
+            .filter(p => p !== 'any')
+            .join(' & ');
+    }
+    // TODO: handle Array.isArray(schema.type) case b4 switch
+    switch (schema.type) {
+        case 'object': return '{ [key: string]: any }';
+        case 'string':
+            if (schema.const) {
+                return `'${schema.const}'`;
+            }
+            return 'string';
+        case 'integer': return 'number';
+        case 'number': return 'number';
+        case 'boolean': return 'boolean';
+        case 'array': return handleArrayItems(schema);
+        case 'undefined': return 'undefined';
+        case 'null': return 'null';
+        case undefined: return 'any';
+        default:
+            console.log('Unknown type', schema.type);
+            return 'unknown';
+    }
+}
+export function isOptional(schema) {
+    /// / !schema?.required?.includes(schema.title || '')
+    const type = schemaToType(schema);
+    const splitType = type.split(/\s+\|\s+/);
+    const includesNull = splitType.includes('null');
+    const includesUndefined = splitType.includes('undefined');
+    return includesNull || includesUndefined || schema?.default !== undefined;
+}
+export function cleanOptionals(str) {
+    return str
+        .split(' | ')
+        .filter(t => t !== 'null' && t !== 'undefined')
+        .join(' | ');
+}
+export function formatVarType({ varName, schema, required = false, defaultValue, }) {
+    let type = schemaToType(schema);
+    type = cleanOptionals(type);
+    let defaultStr = '';
+    if (defaultValue) {
+        if (typeof defaultValue === 'string') {
+            defaultStr = ` = '${defaultValue}'`;
+        }
+        else if (typeof defaultValue === 'object') {
+            defaultStr = ` = ${JSON.stringify(defaultValue)}`;
+        }
+        else {
+            defaultStr = ` = ${defaultValue}`;
+        }
+    }
+    let optionalStr = (!required && isOptional(schema)) ? '?' : '';
+    if (defaultStr) {
+        optionalStr = '';
+    }
+    return `${varName}${optionalStr}: ${type}${defaultStr}`;
+}
+/**
+ * List of JavaScript/TypeScript reserved keywords and common identifiers to avoid
+ */
+const RESERVED_KEYWORDS = new Set([
+    // JavaScript reserved words
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'import',
+    'in',
+    'instanceof',
+    'new',
+    'null',
+    'return',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+    // TypeScript reserved words
+    'abstract',
+    'any',
+    'as',
+    'asserts',
+    'bigint',
+    'boolean',
+    'constructor',
+    'declare',
+    'get',
+    'infer',
+    'intrinsic',
+    'is',
+    'keyof',
+    'module',
+    'namespace',
+    'never',
+    'number',
+    'object',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'readonly',
+    'require',
+    'set',
+    'static',
+    'string',
+    'symbol',
+    'type',
+    'undefined',
+    'unique',
+    'unknown',
+    // Strict mode reserved words
+    'implements',
+    'interface',
+    'let',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    // Common global identifiers to avoid
+    'arguments',
+    'eval',
+    'Infinity',
+    'NaN',
+    'undefined',
+    'globalThis',
+    'window',
+    'document',
+    'console',
+    'Object',
+    'Array',
+    'Function',
+    'String',
+    'Number',
+    'Boolean',
+    'Date',
+    'RegExp',
+    'Error',
+    'Promise',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Symbol',
+    'Proxy',
+    'Reflect'
+]);
+/**
+ * Sanitizes a variable name to ensure it's not a reserved keyword
+ * @param varName - The variable name to sanitize
+ * @returns A safe variable name
+ */
+export function sanitizeVarName(varName) {
+    if (!varName) {
+        return varName;
+    }
+    // If it's a reserved keyword, append underscore
+    if (RESERVED_KEYWORDS.has(varName.toLowerCase())) {
+        return `${varName}_`;
+    }
+    return varName;
+}
+/**
+ * Converts a string to camelCase and ensures it's not a reserved keyword
+ * @param str - The string to convert
+ * @returns A safe camelCase variable name
+ */
+export function toCamelCaseSafe(str) {
+    const camelCased = toCamelCase(str);
+    return sanitizeVarName(camelCased);
+}
+export function cleanPath(path) {
+    return path
+        .split('/')
+        .filter(p => p && !/\{|\}/.test(p))
+        .join('/');
+}

package/src/unwrap.js

@@ -0,0 +1,30 @@
+/**
+ * Unwrap utility for ApiResponse
+ *
+ * Use this when you need to assign API responses to plain types
+ */
+/**
+ * Unwrap an ApiResponse to get the plain data
+ *
+ * @example
+ * import { unwrap } from '@bagelink/sdk'
+ *
+ * const agent = ref<AgentResponse | null>(null)
+ * agent.value = unwrap(await api.agents.getByAgentId({ agentId }))
+ */
+export function unwrap(response) {
+    // If it's already unwrapped, return as-is
+    if (!response || typeof response !== 'object') {
+        return response;
+    }
+    // If it's an array (ApiResponse extends Array), return as-is
+    if (Array.isArray(response)) {
+        return response;
+    }
+    // If it has $raw, it's an enhanced object - return without metadata
+    if ('$raw' in response) {
+        const { $raw, $metadata, totalCount, page, perPage, totalPages, rateLimit, rateLimitReset, getHeader, hasPagination, hasNextPage, hasPrevPage, ...data } = response;
+        return data;
+    }
+    return response;
+}

package/src/utils.js

@@ -0,0 +1,58 @@
+export function formatAPIErrorMessage(err) {
+    const error = err;
+    // Handle case where error or response is undefined
+    if (!error || !error.response) {
+        return 'Network error occurred. Please check your connection.';
+    }
+    const { status, data } = error.response;
+    // Handle validation errors (422)
+    if (data.detail && Array.isArray(data.detail)) {
+        return data.detail
+            .map((err) => {
+            // Handle nested field paths properly
+            const fieldPath = err.loc.slice(1).join('.');
+            const field = fieldPath
+                .split('.')
+                .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+                .join(' ');
+            const message = err.msg
+                // Common validation messages
+                .replace(/^(?:field|value|string|none) required$/i, 'is required')
+                .replace(/^value is not a valid/i, 'must be a valid')
+                .replace(/^ensure this value/i, 'this value must')
+                .replace(/^str type expected$/i, 'must be text')
+                .replace(/^value could not be parsed to/i, 'must be a')
+                .replace(/^ensure this value has at least/i, 'must have at least')
+                .replace(/^ensure this value has at most/i, 'must have at most')
+                .replace(/^invalid datetime format/i, 'must be a valid date/time')
+                .replace(/^value is not a valid email address/i, 'must be a valid email address')
+                .replace(/^value is not a valid integer/i, 'must be a whole number')
+                .replace(/^value is not a valid float/i, 'must be a valid number');
+            return `${field} ${message.toLowerCase()}`;
+        })
+            .join('\n');
+    }
+    // Handle specific HTTP status codes
+    switch (status) {
+        case 401:
+            return 'Authentication required. Please log in.';
+        case 403:
+            return 'You do not have permission to perform this action.';
+        case 404:
+            return 'The requested resource was not found.';
+        case 429:
+            return 'Too many requests. Please try again later.';
+        case 500:
+            return 'An internal server error occurred. Please try again later.';
+    }
+    // Handle other errors with detail
+    if (data.detail && typeof data.detail === 'string') {
+        return data.detail;
+    }
+    // Handle errors with a message field
+    if (data.message) {
+        return data.message;
+    }
+    // Generic error fallback
+    return `An error occurred (Status ${status}): ${error.message || 'Unknown error'}`;
+}