@bagelink/sdk 1.4.26 → 1.4.30

package/dist/index.d.ts

@@ -1,3 +1,355 @@
+declare function getPath(pathsObject: PathsObject | undefined, path: string): PathItemObject | 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.
+ */
+declare function isReferenceObject(obj: any): obj is ReferenceObject;
+/**
+ * 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.
+ */
+declare function isSchemaObject(schema: SchemaObject | ReferenceObject): schema is SchemaObject;
+declare function dereference<T>(property: ReferenceObject | T): Exclude<T, ReferenceObject>;
+
+interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+        [v: string]: ServerVariableObject;
+    };
+}
+interface ServerVariableObject {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+}
+interface OpenAPIObject {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths?: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    /** Webhooks added in v. 3.1.0 */
+    webhooks?: PathsObject;
+}
+interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+interface LicenseObject {
+    name: string;
+    identifier?: string;
+    url?: string;
+}
+interface ComponentsObject {
+    schemas?: {
+        [schema: string]: SchemaObject | ReferenceObject;
+    };
+    responses?: {
+        [response: string]: ResponseObject | ReferenceObject;
+    };
+    parameters?: {
+        [parameter: string]: ParameterObject | ReferenceObject;
+    };
+    examples?: {
+        [example: string]: ExampleObject | ReferenceObject;
+    };
+    requestBodies?: {
+        [request: string]: RequestBodyObject | ReferenceObject;
+    };
+    headers?: {
+        [header: string]: HeaderObject | ReferenceObject;
+    };
+    securitySchemes?: {
+        [securityScheme: string]: SecuritySchemeObject | ReferenceObject;
+    };
+    links?: {
+        [link: string]: LinkObject | ReferenceObject;
+    };
+    callbacks?: {
+        [callback: string]: CallbackObject | ReferenceObject;
+    };
+}
+/**
+ * Rename it to Paths Object to be consistent with the spec
+ * See https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#pathsObject
+ */
+interface PathsObject {
+    [path: string]: PathItemObject;
+}
+interface PathItemObject {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+interface OperationObject {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses?: ResponsesObject;
+    callbacks?: CallbacksObject;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+/**
+ * The location of a parameter.
+ * Possible values are "query", "header", "path" or "cookie".
+ * Specification:
+ * https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-locations
+ */
+type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+/**
+ * The style of a parameter.
+ * Describes how the parameter value will be serialized.
+ * (serialization is not implemented yet)
+ * Specification:
+ * https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
+ */
+type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+interface BaseParameterObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject | ReferenceObject;
+    examples?: {
+        [param: string]: ExampleObject | ReferenceObject;
+    };
+    example?: any;
+    content?: ContentObject;
+}
+interface ParameterObject extends BaseParameterObject {
+    name: string;
+    in: ParameterLocation;
+}
+interface RequestBodyObject {
+    description?: string;
+    content: ContentObject;
+    required?: boolean;
+}
+interface ContentObject {
+    [mediatype: string]: MediaTypeObject;
+}
+interface MediaTypeObject {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+interface EncodingObject {
+    [property: string]: EncodingPropertyObject;
+}
+interface EncodingPropertyObject {
+    contentType?: string;
+    headers?: {
+        [key: string]: HeaderObject | ReferenceObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+interface ResponsesObject {
+    [statuscode: string]: ResponseObject | ReferenceObject;
+}
+interface ResponseObject {
+    description: string;
+    headers?: HeadersObject;
+    content?: ContentObject;
+    links?: LinksObject;
+}
+interface CallbacksObject {
+    [name: string]: CallbackObject | ReferenceObject;
+}
+interface CallbackObject {
+    [name: string]: PathItemObject;
+}
+interface HeadersObject {
+    [name: string]: HeaderObject | ReferenceObject;
+}
+interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+interface LinksObject {
+    [name: string]: LinkObject | ReferenceObject;
+}
+interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+}
+interface LinkParametersObject {
+    [name: string]: any | string;
+}
+interface HeaderObject extends BaseParameterObject {
+    $ref?: string;
+}
+interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+interface ExamplesObject {
+    [name: string]: ExampleObject | ReferenceObject;
+}
+interface ReferenceObject {
+    $ref: string;
+    summary?: string;
+    description?: string;
+}
+type SchemaObjectType = 'integer' | 'number' | 'string' | 'boolean' | 'object' | 'null' | 'array' | 'undefined';
+declare const TYPE_FORMATS: readonly ["uuid", "uri", "date-time", "date", "email", "binary", "password", "phone", "uuid4", "int32", "int64", "float", "double", "byte"];
+type TypeFormatT = (typeof TYPE_FORMATS)[number] | (string & {});
+interface SchemaObject {
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    /** @deprecated use examples instead */
+    example?: any;
+    examples?: any[];
+    deprecated?: boolean;
+    type?: SchemaObjectType | SchemaObjectType[];
+    format?: TypeFormatT;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: {
+        [propertyName: string]: SchemaObject | ReferenceObject;
+    };
+    additionalProperties?: SchemaObject | ReferenceObject | boolean;
+    propertyNames?: SchemaObject | ReferenceObject;
+    description?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    const?: any;
+    /** @desc In OpenAPI 3.1: number */
+    exclusiveMaximum?: number;
+    minimum?: number;
+    /** @desc In OpenAPI 3.1: number */
+    exclusiveMinimum?: number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    prefixItems?: (SchemaObject | ReferenceObject)[];
+    /**
+     * @desc JSON Schema compliant Content-Type, optional when specified as a key of ContentObject
+     * @example image/png
+     */
+    contentMediaType?: string;
+    /**
+     * @desc Specifies the Content-Encoding for the schema, supports all encodings from RFC4648, and "quoted-printable" from RFC2045
+     * @override
+     * @see https://datatracker.ietf.org/doc/html/rfc4648
+     * @see https://datatracker.ietf.org/doc/html/rfc2045#section-6.7
+     * @example base64
+     */
+    contentEncoding?: string;
+}
+interface SchemasObject {
+    [schema: string]: SchemaObject;
+}
+interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+        [key: string]: string;
+    };
+}
+interface XmlObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+interface SecuritySchemeObject {
+    type: SecuritySchemeType;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject;
+    openIdConnectUrl?: string;
+}
+interface OAuthFlowsObject {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+interface OAuthFlowObject {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+interface ScopesObject {
+    [scope: string]: any;
+}
+interface SecurityRequirementObject {
+    [name: string]: string[];
+}
+
 interface OpenAPIResponse {
     types: string;
     code: string;
@@ -8,7 +360,6 @@ declare function formatAPIErrorMessage(err: unknown): string;
 
 type Tables = '';
 type TableToTypeMapping = Record<Tables, any>;
-
 interface User {
     id: string;
     first_name?: string;
@@ -108,4 +459,5 @@ declare class Bagel {
     uploadFile<T>(file: File, options?: UploadOptions): Promise<T>;
 }
 
-export { Bagel, type TableToTypeMapping, type Tables, type UploadOptions, type User, formatAPIErrorMessage, _default as openAPI };
+export { Bagel, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, _default as openAPI };
+export type { BaseParameterObject, CallbackObject, CallbacksObject, ComponentsObject, ContactObject, ContentObject, DiscriminatorObject, EncodingObject, EncodingPropertyObject, ExampleObject, ExamplesObject, ExternalDocumentationObject, HeaderObject, HeadersObject, InfoObject, LicenseObject, LinkObject, LinkParametersObject, LinksObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SchemaObjectType, SchemasObject, ScopesObject, SecurityRequirementObject, SecuritySchemeObject, SecuritySchemeType, ServerObject, ServerVariableObject, TableToTypeMapping, Tables, TagObject, TypeFormatT, UploadOptions, User, XmlObject };

package/dist/index.mjs

@@ -1,5 +1,19 @@
 import axios$1 from 'axios';
 
+function getPath(pathsObject, path) {
+  return pathsObject ? pathsObject[path] : void 0;
+}
+function isReferenceObject(obj) {
+  if (!obj) return false;
+  return Object.prototype.hasOwnProperty.call(obj, "$ref");
+}
+function isSchemaObject(schema) {
+  return !Object.prototype.hasOwnProperty.call(schema, "$ref");
+}
+function dereference(property) {
+  return property;
+}
+
 function toCamelCase(str) {
   return str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
 }
@@ -32,6 +46,13 @@ function handleArrayItems(schema) {
 }
 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";
@@ -40,7 +61,6 @@ function schemaToType(schema) {
   if (schema.allOf) {
     return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
   }
-  if (schema.$ref) return resolveReference(schema.$ref);
   switch (schema.type) {
     case "object":
       return "{ [key: string]: any }";
@@ -73,7 +93,7 @@ function isOptional(schema) {
   const splitType = type.split(/\s+\|\s+/);
   const includesNull = splitType.includes("null");
   const includesUndefined = splitType.includes("undefined");
-  return includesNull || includesUndefined || schema.default !== void 0;
+  return includesNull || includesUndefined || schema?.default !== void 0;
 }
 function cleanOptionals(str) {
   return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
@@ -136,6 +156,9 @@ function schemaToTypeWithCollection(schema) {
   return type;
 }
 function getResponseType(response) {
+  if (isReferenceObject(response)) {
+    return void 0;
+  }
   const mediaTypeObject = response.content?.["application/json"];
   if (!mediaTypeObject?.schema) return void 0;
   return schemaToTypeWithCollection(mediaTypeObject.schema);
@@ -163,12 +186,13 @@ function formatPathWithParams(path) {
   return `\`${path.replace(/\{([^}]+)\}/g, (_, paramName) => `\${${toCamelCase(paramName)}}`)}\``;
 }
 function generateRequestBody(requestBody) {
-  if (!requestBody?.content)
+  const content = dereference(requestBody)?.content;
+  if (!content || Object.keys(content).length === 0) {
     return { requestBodyParam: "", requestBodyPayload: "" };
-  const { content } = requestBody;
+  }
   if (content["multipart/form-data"]) {
     const multipartFormData = content["multipart/form-data"];
-    if (multipartFormData.schema?.$ref?.includes("Body_upload_files")) {
+    if (isReferenceObject(multipartFormData.schema) && multipartFormData.schema?.$ref?.includes("Body_upload_files")) {
       return {
         requestBodyParam: "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }",
         requestBodyPayload: "formData"
@@ -183,7 +207,7 @@ function generateRequestBody(requestBody) {
   if (!jsonContent || !jsonContent.schema) {
     return { requestBodyParam: "", requestBodyPayload: "" };
   }
-  const bodySchema = jsonContent.schema;
+  const bodySchema = dereference(jsonContent.schema);
   const requestBodyType = schemaToType(bodySchema);
   collectTypeForImportStatement(requestBodyType);
   const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
@@ -207,8 +231,10 @@ function generateFunctionParameters(params, isFileUpload = false) {
   }
   const functionParams = [];
   const queryParams = [];
-  for (const param of params) {
-    const paramType = schemaToType(param.schema);
+  for (const p of params) {
+    const param = dereference(p);
+    const pSchema = dereference(param.schema);
+    const paramType = schemaToType(pSchema);
     collectTypeForImportStatement(paramType);
     const paramName = param.name;
     const varName = toCamelCase(param.name);
@@ -216,9 +242,9 @@ function generateFunctionParameters(params, isFileUpload = false) {
       functionParams.push(
         formatVarType({
           varName,
-          schema: param.schema,
+          schema: pSchema,
           required: param.required,
-          defaultValue: param.schema.default
+          defaultValue: pSchema?.default
         })
       );
     }
@@ -293,7 +319,8 @@ function buildJSDocComment(operation, method, path) {
 }
 function generateFunctionForOperation(method, path, operation) {
   if (!operation) return "";
-  const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
+  const multiPartSchema = dereference(operation.requestBody)?.content?.["multipart/form-data"]?.schema;
+  const isFileUpload = isReferenceObject(multiPartSchema) && multiPartSchema?.$ref?.includes("Body_upload_files");
   const parameters = generateFunctionParameters(
     operation.parameters,
     isFileUpload
@@ -419,13 +446,16 @@ ${tsString}`;
 }
 
 function generateTypes(schemas) {
-  return Object.entries(schemas).map(([typeName, schema]) => {
-    typeName = formatType(typeName);
-    if (schema.enum) {
+  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(" | ")};
 `;
     }
-    if (schema.type === "array" && schema.items) {
+    if (schema?.type === "array" && schema.items) {
       return `export type ${typeName} = (${schemaToType(schema.items)})[];
 `;
     }
@@ -570,7 +600,6 @@ function responses(key) {
 class BagelAuth {
   constructor(bagel) {
     this.bagel = bagel;
-    this.bagel = bagel;
   }
   user = void 0;
   async validateUser() {
@@ -733,4 +762,4 @@ class Bagel {
   }
 }
 
-export { Bagel, formatAPIErrorMessage, index as openAPI };
+export { Bagel, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, index as openAPI };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "1.4.26",
+  "version": "1.4.30",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Neveh Allon",
@@ -51,31 +51,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/typescript-estree": "^8.32.1",
     "axios": "^1.9.0"
   },
   "devDependencies": {
-    "@apidevtools/swagger-parser": "^10.1.1",
-    "handlebars": "^4.7.8",
-    "openapi-zod-client": "^1.18.3",
-    "openapi3-ts": "^3.1.0"
+    "@typescript-eslint/typescript-estree": "^8.33.0"
   },
   "peerDependencies": {
-    "@apidevtools/swagger-parser": "^10.1.0",
-    "openapi-zod-client": "^1.18.2",
-    "openapi3-ts": "^3.1.0"
-  },
-  "peerDependenciesMeta": {
-    "@apidevtools/swagger-parser": {
-      "optional": true
-    },
-    "openapi-zod-client": {
-      "optional": true
-    },
-    "openapi3-ts": {
-      "optional": true
-    }
+    "@typescript-eslint/typescript-estree": "^8.33.0",
+    "type-fest": "^4"
   },
+  "peerDependenciesMeta": {},
   "scripts": {
     "dev": "unbuild --stub",
     "build": "unbuild",

package/src/index.ts

@@ -1,11 +1,11 @@
 import ax from 'axios'
 
-import openAPI from './openAPITools'
+export * from './openAPITools'
+export { default as openAPI } from './openAPITools'
 
 export type Tables = ''
 export type TableToTypeMapping = Record<Tables, any>
 
-export { openAPI }
 export interface User {
 	id: string
 	first_name?: string
@@ -108,9 +108,7 @@ function responses(key: string) {
 }
 
 class BagelAuth {
-	constructor(private bagel: Bagel) {
-		this.bagel = bagel
-	}
+	constructor(private bagel: Bagel) {}
 
 	user: User | undefined = undefined