@bagelink/sdk 1.4.26 → 1.4.28

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,4 @@ 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, type BaseParameterObject, type CallbackObject, type CallbacksObject, type ComponentsObject, type ContactObject, type ContentObject, type DiscriminatorObject, type EncodingObject, type EncodingPropertyObject, type ExampleObject, type ExamplesObject, type ExternalDocumentationObject, type HeaderObject, type HeadersObject, type InfoObject, type LicenseObject, type LinkObject, type LinkParametersObject, type LinksObject, type MediaTypeObject, type OAuthFlowObject, type OAuthFlowsObject, type OpenAPIObject, type OperationObject, type ParameterLocation, type ParameterObject, type ParameterStyle, type PathItemObject, type PathsObject, type ReferenceObject, type RequestBodyObject, type ResponseObject, type ResponsesObject, type SchemaObject, type SchemaObjectType, type SchemasObject, type ScopesObject, type SecurityRequirementObject, type SecuritySchemeObject, type SecuritySchemeType, type ServerObject, type ServerVariableObject, type TableToTypeMapping, type Tables, type TagObject, type TypeFormatT, type UploadOptions, type User, type XmlObject, dereference, formatAPIErrorMessage, getPath, isReferenceObject, isSchemaObject, _default as openAPI };

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.28",
   "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