@snagsolutions/sdk 0.1.0-alpha.15 → 0.1.0-alpha.151

package/src/core.ts

@@ -16,7 +16,12 @@ import {
   type RequestInit,
   type Response,
   type HeadersInit,
+  init,
 } from './_shims/index';
+
+// try running side effects outside of _shims/index to workaround https://github.com/vercel/next.js/issues/76881
+init();
+
 export { type Response };
 import { BlobLike, isBlobLike, isMultipartBody } from './uploads';
 export {
@@ -28,6 +33,20 @@ export {
 
 export type Fetch = (url: RequestInfo, init?: RequestInit) => Promise<Response>;
 
+/**
+ * An alias to the builtin `Array` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Array<T> = Array<T>;
+
+/**
+ * An alias to the builtin `Record` type so we can
+ * easily alias it in import statements if there are name clashes.
+ */
+type _Record<K extends keyof any, T> = Record<K, T>;
+
+export type { _Array as Array, _Record as Record };
+
 type PromiseOrValue<T> = T | Promise<T>;
 
 type APIResponseProps = {
@@ -151,6 +170,7 @@ export class APIPromise<T> extends Promise<T> {
 
 export abstract class APIClient {
   baseURL: string;
+  #baseURLOverridden: boolean;
   maxRetries: number;
   timeout: number;
   httpAgent: Agent | undefined;
@@ -160,18 +180,21 @@ export abstract class APIClient {
 
   constructor({
     baseURL,
+    baseURLOverridden,
     maxRetries = 2,
     timeout = 60000, // 1 minute
     httpAgent,
     fetch: overriddenFetch,
   }: {
     baseURL: string;
+    baseURLOverridden: boolean;
     maxRetries?: number | undefined;
     timeout: number | undefined;
     httpAgent: Agent | undefined;
     fetch: Fetch | undefined;
   }) {
     this.baseURL = baseURL;
+    this.#baseURLOverridden = baseURLOverridden;
     this.maxRetries = validatePositiveInteger('maxRetries', maxRetries);
     this.timeout = validatePositiveInteger('timeout', timeout);
     this.httpAgent = httpAgent;
@@ -194,7 +217,7 @@ export abstract class APIClient {
   protected defaultHeaders(opts: FinalRequestOptions): Headers {
     return {
       Accept: 'application/json',
-      'Content-Type': 'application/json',
+      ...(['head', 'get'].includes(opts.method) ? {} : { 'Content-Type': 'application/json' }),
       'User-Agent': this.getUserAgent(),
       ...getPlatformHeaders(),
       ...this.authHeaders(opts),
@@ -276,12 +299,12 @@ export abstract class APIClient {
     return null;
   }
 
-  buildRequest<Req>(
-    options: FinalRequestOptions<Req>,
+  async buildRequest<Req>(
+    inputOptions: FinalRequestOptions<Req>,
     { retryCount = 0 }: { retryCount?: number } = {},
-  ): { req: RequestInit; url: string; timeout: number } {
-    options = { ...options };
-    const { method, path, query, headers: headers = {} } = options;
+  ): Promise<{ req: RequestInit; url: string; timeout: number }> {
+    const options = { ...inputOptions };
+    const { method, path, query, defaultBaseURL, headers: headers = {} } = options;
 
     const body =
       ArrayBuffer.isView(options.body) || (options.__binaryRequest && typeof options.body === 'string') ?
@@ -291,7 +314,7 @@ export abstract class APIClient {
       : null;
     const contentLength = this.calculateContentLength(body);
 
-    const url = this.buildURL(path!, query);
+    const url = this.buildURL(path!, query, defaultBaseURL);
     if ('timeout' in options) validatePositiveInteger('timeout', options.timeout);
     options.timeout = options.timeout ?? this.timeout;
     const httpAgent = options.httpAgent ?? this.httpAgent ?? getDefaultAgent(url);
@@ -308,8 +331,8 @@ export abstract class APIClient {
     }
 
     if (this.idempotencyHeader && method !== 'get') {
-      if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey();
-      headers[this.idempotencyHeader] = options.idempotencyKey;
+      if (!inputOptions.idempotencyKey) inputOptions.idempotencyKey = this.defaultIdempotencyKey();
+      headers[this.idempotencyHeader] = inputOptions.idempotencyKey;
     }
 
     const reqHeaders = this.buildHeaders({ options, headers, contentLength, retryCount });
@@ -366,7 +389,7 @@ export abstract class APIClient {
       getHeader(headers, 'x-stainless-timeout') === undefined &&
       options.timeout
     ) {
-      reqHeaders['x-stainless-timeout'] = String(options.timeout);
+      reqHeaders['x-stainless-timeout'] = String(Math.trunc(options.timeout / 1000));
     }
 
     this.validateHeaders(reqHeaders, headers);
@@ -395,7 +418,7 @@ export abstract class APIClient {
       !headers ? {}
       : Symbol.iterator in headers ?
         Object.fromEntries(Array.from(headers as Iterable<string[]>).map((header) => [...header]))
-      : { ...headers }
+      : { ...(headers as any as Record<string, string>) }
     );
   }
 
@@ -427,7 +450,9 @@ export abstract class APIClient {
 
     await this.prepareOptions(options);
 
-    const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining });
+    const { req, url, timeout } = await this.buildRequest(options, {
+      retryCount: maxRetries - retriesRemaining,
+    });
 
     await this.prepareRequest(req, { url, options });
 
@@ -484,11 +509,12 @@ export abstract class APIClient {
     return new PagePromise<PageClass, Item>(this, request, Page);
   }
 
-  buildURL<Req>(path: string, query: Req | null | undefined): string {
+  buildURL<Req>(path: string, query: Req | null | undefined, defaultBaseURL?: string | undefined): string {
+    const baseURL = (!this.#baseURLOverridden && defaultBaseURL) || this.baseURL;
     const url =
       isAbsoluteURL(path) ?
         new URL(path)
-      : new URL(this.baseURL + (this.baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
+      : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
 
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
@@ -773,6 +799,7 @@ export type RequestOptions<
   query?: Req | undefined;
   body?: Req | null | undefined;
   headers?: Headers | undefined;
+  defaultBaseURL?: string | undefined;
 
   maxRetries?: number;
   stream?: boolean | undefined;
@@ -794,6 +821,7 @@ const requestOptionsKeys: KeysEnum<RequestOptions> = {
   query: true,
   body: true,
   headers: true,
+  defaultBaseURL: true,
 
   maxRetries: true,
   stream: true,
@@ -1060,21 +1088,21 @@ export const coerceBoolean = (value: unknown): boolean => {
 };
 
 export const maybeCoerceInteger = (value: unknown): number | undefined => {
-  if (value === undefined) {
+  if (value == null) {
     return undefined;
   }
   return coerceInteger(value);
 };
 
 export const maybeCoerceFloat = (value: unknown): number | undefined => {
-  if (value === undefined) {
+  if (value == null) {
     return undefined;
   }
   return coerceFloat(value);
 };
 
 export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
-  if (value === undefined) {
+  if (value == null) {
     return undefined;
   }
   return coerceBoolean(value);

package/src/index.ts

@@ -6,19 +6,48 @@ import * as Core from './core';
 import * as Errors from './error';
 import * as Uploads from './uploads';
 import * as API from './resources/index';
+import { AssetCreateAssetParams, AssetCreateAssetResponse, Assets } from './resources/assets';
+import { Auth, AuthConnectAuthParams, AuthConnectAuthResponse } from './resources/auth';
+import { Minting, MintingGetAssetsParams, MintingGetAssetsResponse } from './resources/minting';
 import {
-  API as ApiapiAPI,
-  APICreateAssetUploadURLParams,
-  APICreateAssetUploadURLResponse,
-  APIListAuctionBidsParams,
-  APIListAuctionsResponse,
-  APIListUsersParams,
-  APIListUsersResponse,
-} from './resources/api/api';
+  AuctionGetPageSectionsParams,
+  AuctionGetPageSectionsResponse,
+  AuctionListAuctionBidsParams,
+  AuctionListAuctionsResponse,
+  Auctions,
+} from './resources/auctions/auctions';
+import { Loyalty } from './resources/loyalty/loyalty';
+import {
+  Referral,
+  ReferralCreateCodeParams,
+  ReferralCreateCodeResponse,
+} from './resources/referral/referral';
+import {
+  UserConnectParams,
+  UserConnectResponse,
+  UserCountParams,
+  UserCountResponse,
+  UserCreateDeviceParams,
+  UserCreateDeviceResponse,
+  UserDisconnectParams,
+  UserDisconnectResponse,
+  UserListParams,
+  UserListResponse,
+  UserVerifyParams,
+  UserVerifyResponse,
+  Users,
+} from './resources/users/users';
+import {
+  WebsiteCreateParams,
+  WebsiteCreateResponse,
+  WebsiteListParams,
+  WebsiteListResponse,
+  Websites,
+} from './resources/websites/websites';
 
 export interface ClientOptions {
   /**
-   * Defaults to process.env['SNAG_SOLUTIONS_API_KEY'].
+   * API key required to authenticate with the Snag Solutions API.
    */
   apiKey?: string | undefined;
 
@@ -35,6 +64,8 @@ export interface ClientOptions {
    *
    * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
    * much longer than this timeout before the promise succeeds or fails.
+   *
+   * @unit milliseconds
    */
   timeout?: number | undefined;
 
@@ -90,8 +121,8 @@ export class SnagSolutions extends Core.APIClient {
   /**
    * API Client for interfacing with the Snag Solutions API.
    *
-   * @param {string | undefined} [opts.apiKey=process.env['SNAG_SOLUTIONS_API_KEY'] ?? undefined]
-   * @param {string} [opts.baseURL=process.env['SNAG_SOLUTIONS_BASE_URL'] ?? https://api.example.com] - Override the default base URL for the API.
+   * @param {string | undefined} [opts.apiKey=process.env['X_API_KEY'] ?? undefined]
+   * @param {string} [opts.baseURL=process.env['SNAG_SOLUTIONS_BASE_URL'] ?? https://admin.snagsolutions.io/] - Override the default base URL for the API.
    * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
    * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
@@ -101,23 +132,24 @@ export class SnagSolutions extends Core.APIClient {
    */
   constructor({
     baseURL = Core.readEnv('SNAG_SOLUTIONS_BASE_URL'),
-    apiKey = Core.readEnv('SNAG_SOLUTIONS_API_KEY'),
+    apiKey = Core.readEnv('X_API_KEY'),
     ...opts
   }: ClientOptions = {}) {
     if (apiKey === undefined) {
       throw new Errors.SnagSolutionsError(
-        "The SNAG_SOLUTIONS_API_KEY environment variable is missing or empty; either provide it, or instantiate the SnagSolutions client with an apiKey option, like new SnagSolutions({ apiKey: 'My API Key' }).",
+        "The X_API_KEY environment variable is missing or empty; either provide it, or instantiate the SnagSolutions client with an apiKey option, like new SnagSolutions({ apiKey: 'My API Key' }).",
       );
     }
 
     const options: ClientOptions = {
       apiKey,
       ...opts,
-      baseURL: baseURL || `https://api.example.com`,
+      baseURL: baseURL || `https://admin.snagsolutions.io/`,
     };
 
     super({
       baseURL: options.baseURL!,
+      baseURLOverridden: baseURL ? baseURL !== 'https://admin.snagsolutions.io/' : false,
       timeout: options.timeout ?? 60000 /* 1 minute */,
       httpAgent: options.httpAgent,
       maxRetries: options.maxRetries,
@@ -129,7 +161,21 @@ export class SnagSolutions extends Core.APIClient {
     this.apiKey = apiKey;
   }
 
-  api: API.API = new API.API(this);
+  assets: API.Assets = new API.Assets(this);
+  auth: API.Auth = new API.Auth(this);
+  auctions: API.Auctions = new API.Auctions(this);
+  users: API.Users = new API.Users(this);
+  loyalty: API.Loyalty = new API.Loyalty(this);
+  minting: API.Minting = new API.Minting(this);
+  referral: API.Referral = new API.Referral(this);
+  websites: API.Websites = new API.Websites(this);
+
+  /**
+   * Check whether the base URL is set to its default.
+   */
+  #baseURLOverridden(): boolean {
+    return this.baseURL !== 'https://admin.snagsolutions.io/';
+  }
 
   protected override defaultQuery(): Core.DefaultQuery | undefined {
     return this._options.defaultQuery;
@@ -147,7 +193,7 @@ export class SnagSolutions extends Core.APIClient {
   }
 
   protected override stringifyQuery(query: Record<string, unknown>): string {
-    return qs.stringify(query, { arrayFormat: 'comma' });
+    return qs.stringify(query, { arrayFormat: 'repeat' });
   }
 
   static SnagSolutions = this;
@@ -171,18 +217,74 @@ export class SnagSolutions extends Core.APIClient {
   static fileFromPath = Uploads.fileFromPath;
 }
 
-SnagSolutions.API = ApiapiAPI;
+SnagSolutions.Assets = Assets;
+SnagSolutions.Auth = Auth;
+SnagSolutions.Auctions = Auctions;
+SnagSolutions.Users = Users;
+SnagSolutions.Loyalty = Loyalty;
+SnagSolutions.Minting = Minting;
+SnagSolutions.Referral = Referral;
+SnagSolutions.Websites = Websites;
+
 export declare namespace SnagSolutions {
   export type RequestOptions = Core.RequestOptions;
 
   export {
-    ApiapiAPI as API,
-    type APICreateAssetUploadURLResponse as APICreateAssetUploadURLResponse,
-    type APIListAuctionsResponse as APIListAuctionsResponse,
-    type APIListUsersResponse as APIListUsersResponse,
-    type APICreateAssetUploadURLParams as APICreateAssetUploadURLParams,
-    type APIListAuctionBidsParams as APIListAuctionBidsParams,
-    type APIListUsersParams as APIListUsersParams,
+    Assets as Assets,
+    type AssetCreateAssetResponse as AssetCreateAssetResponse,
+    type AssetCreateAssetParams as AssetCreateAssetParams,
+  };
+
+  export {
+    Auth as Auth,
+    type AuthConnectAuthResponse as AuthConnectAuthResponse,
+    type AuthConnectAuthParams as AuthConnectAuthParams,
+  };
+
+  export {
+    Auctions as Auctions,
+    type AuctionGetPageSectionsResponse as AuctionGetPageSectionsResponse,
+    type AuctionListAuctionsResponse as AuctionListAuctionsResponse,
+    type AuctionGetPageSectionsParams as AuctionGetPageSectionsParams,
+    type AuctionListAuctionBidsParams as AuctionListAuctionBidsParams,
+  };
+
+  export {
+    Users as Users,
+    type UserListResponse as UserListResponse,
+    type UserConnectResponse as UserConnectResponse,
+    type UserCountResponse as UserCountResponse,
+    type UserCreateDeviceResponse as UserCreateDeviceResponse,
+    type UserDisconnectResponse as UserDisconnectResponse,
+    type UserVerifyResponse as UserVerifyResponse,
+    type UserListParams as UserListParams,
+    type UserConnectParams as UserConnectParams,
+    type UserCountParams as UserCountParams,
+    type UserCreateDeviceParams as UserCreateDeviceParams,
+    type UserDisconnectParams as UserDisconnectParams,
+    type UserVerifyParams as UserVerifyParams,
+  };
+
+  export { Loyalty as Loyalty };
+
+  export {
+    Minting as Minting,
+    type MintingGetAssetsResponse as MintingGetAssetsResponse,
+    type MintingGetAssetsParams as MintingGetAssetsParams,
+  };
+
+  export {
+    Referral as Referral,
+    type ReferralCreateCodeResponse as ReferralCreateCodeResponse,
+    type ReferralCreateCodeParams as ReferralCreateCodeParams,
+  };
+
+  export {
+    Websites as Websites,
+    type WebsiteCreateResponse as WebsiteCreateResponse,
+    type WebsiteListResponse as WebsiteListResponse,
+    type WebsiteCreateParams as WebsiteCreateParams,
+    type WebsiteListParams as WebsiteListParams,
   };
 }
 

package/src/resource.ts

@@ -2,7 +2,7 @@
 
 import type { SnagSolutions } from './index';
 
-export class APIResource {
+export abstract class APIResource {
   protected _client: SnagSolutions;
 
   constructor(client: SnagSolutions) {

package/src/resources/assets.ts

@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import * as Core from '../core';
+
+export class Assets extends APIResource {
+  /**
+   * This endpoint enables you to upload a file to the resource. Returns a presigned
+   * URL and the asset's public URL. Call PUT with the file as the body to upload the
+   * asset using the presigned URL.
+   *
+   * @example
+   * ```ts
+   * const response = await client.assets.createAsset({
+   *   fileName: 'example.png',
+   *   fileSize: 1024,
+   * });
+   * ```
+   */
+  createAsset(
+    body: AssetCreateAssetParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<AssetCreateAssetResponse> {
+    return this._client.post('/api/assets', { body, ...options });
+  }
+}
+
+/**
+ * Response returned upon successful generation of the signed URL for uploading the
+ * file.
+ */
+export interface AssetCreateAssetResponse {
+  /**
+   * The pre-signed URL to be used for uploading the file.
+   */
+  signedUrl: string;
+
+  /**
+   * The URL of the uploaded file.
+   */
+  url: string;
+}
+
+export interface AssetCreateAssetParams {
+  /**
+   * The name of the file, must match the regex pattern (converted to lowercase) and
+   * have a valid extension.
+   */
+  fileName: string;
+
+  /**
+   * Size of the file in bytes. Uploaded file must match this file size. 1mb for
+   * images and 10mb for videos.
+   */
+  fileSize: number;
+
+  /**
+   * The file path, must be a valid enum value.
+   */
+  filePath?:
+    | 'announcements'
+    | 'images'
+    | 'videos'
+    | 'banners'
+    | 'fonts'
+    | 'posts'
+    | 'profiles'
+    | 'minting'
+    | 'loyalty'
+    | 'tokenClaims';
+
+  /**
+   * UUID of the organization (optional, converted to lowercase)
+   */
+  organizationId?: string;
+
+  /**
+   * UUID of the user (optional, converted to lowercase)
+   */
+  userId?: string;
+
+  /**
+   * UUID of the website (optional, converted to lowercase)
+   */
+  websiteId?: string;
+}
+
+export declare namespace Assets {
+  export {
+    type AssetCreateAssetResponse as AssetCreateAssetResponse,
+    type AssetCreateAssetParams as AssetCreateAssetParams,
+  };
+}