@nextplus/js-sdk 0.0.1 → 0.0.4

package/src/index.ts

@@ -0,0 +1,219 @@
+import debug from 'debug';
+import { createClient } from './sdk/client';
+import { UserModelService } from './sdk';
+import * as AllServices from './sdk';
+
+const log = debug('nextplus:sdk');
+
+const accessToken = {
+  token: null as string | null,
+  created: null as Date | null,
+  ttl: 0,
+};
+
+const setAccessToken = (token: string, created: Date = new Date(), ttl: number = 1209600) => {
+  accessToken.token = token;
+  accessToken.created = created;
+  accessToken.ttl = ttl;
+};
+
+const getAccessToken = () => {
+  return accessToken;
+};
+
+const isTokenValid = (): boolean => {
+  if (!accessToken.token || !accessToken.created) {
+    return false;
+  }
+
+  const now = new Date();
+  const tokenAge = now.getTime() - accessToken.created.getTime();
+  const tokenTtlMs = accessToken.ttl * 1000; // TTL is in seconds
+
+  return tokenAge < tokenTtlMs;
+};
+
+
+
+class NextPlusSDK {
+  private client: any;
+  private credentials: { email?: string; username?: string; password: string };
+  private returnType: 'raw' | 'data' = 'data';
+
+  constructor(options: {
+    baseURL: string;
+    email?: string;
+    username?: string;
+    password: string;
+    returnType?: 'raw' | 'data';
+  }) {
+    // Validate that either email or username is provided
+    if (!options.email && !options.username) {
+      throw new Error('Either email or username must be provided');
+    }
+    if (options.email && options.username) {
+      throw new Error('Provide either email or username, not both');
+    }
+
+    this.credentials = {
+      email: options.email,
+      username: options.username,
+      password: options.password
+    };
+    this.returnType = options.returnType || 'data';
+    // remove trailing slash from baseURL
+    if (options.baseURL.endsWith('/')) {
+      options.baseURL = options.baseURL.slice(0, -1);
+    }
+    // if baseURL does not end with /api, add it
+    if (!options.baseURL.endsWith('/api')) {
+      options.baseURL = options.baseURL + '/api';
+    }
+    this.client = createClient({
+      baseUrl: options.baseURL,
+    });
+
+    // Add authentication interceptor
+    this.client.interceptors.request.use(this.authRequestInterceptor.bind(this));
+
+    // Create service proxies dynamically
+    this.createServiceProxies();
+  }
+
+  private async authRequestInterceptor(request: Request, _options: any) {
+    // Skip for UserModels/login
+    if (request.url.includes('/UserModels/login')) {
+      return request;
+    }
+
+    // Ensure we have a valid token
+    await this.ensureValidToken();
+
+    const token = getAccessToken();
+    if (token.token) {
+      request.headers.set('Authorization', token.token);
+    }
+    return request;
+  }
+
+  private async ensureValidToken(): Promise<void> {
+    if (!isTokenValid()) {
+      log('Token expired or missing, refreshing...');
+      await this.login();
+    }
+  }
+
+  private async login(): Promise<boolean> {
+    try {
+      const loginBody: any = {
+        password: this.credentials.password,
+        forceLogin: true,
+      };
+
+      // Use email if provided, otherwise use username
+      if (this.credentials.email) {
+        loginBody.email = this.credentials.email;
+      } else if (this.credentials.username) {
+        loginBody.username = this.credentials.username;
+      }
+
+      const response = await UserModelService.login({
+        client: this.client,
+        body: loginBody,
+      });
+
+      if (response.data) {
+        const token = (response.data as any).id;
+        const ttl = (response.data as any).ttl || 1209600;
+        if (token) {
+          setAccessToken(token, new Date(), ttl);
+          log('Login successful, access token set');
+          return true;
+        }
+      }
+
+      throw new Error('Login failed - no token received');
+    } catch (error) {
+      console.error('Login failed:', error);
+      throw error;
+    }
+  }
+
+  private createServiceProxies() {
+    // Get all service classes from the SDK
+    const serviceNames = Object.keys(AllServices).filter(key =>
+      key.endsWith('Service') && typeof (AllServices as any)[key] === 'function'
+    );
+
+    serviceNames.forEach(serviceName => {
+      const ServiceClass = (AllServices as any)[serviceName];
+
+      // Create a proxy for each service
+      (this as any)[serviceName] = this.createServiceProxy(ServiceClass);
+    });
+  }
+
+  private createServiceProxy(ServiceClass: any) {
+    const self = this;
+    return new Proxy(ServiceClass, {
+      get(target, prop) {
+        if (typeof target[prop] === 'function') {
+          return async function(...args: any[]) {
+            // Automatically inject client if not provided
+            if (args[0] && typeof args[0] === 'object' && !args[0].client) {
+              args[0].client = self.client;
+            } else if (!args[0]) {
+              args[0] = { client: self.client };
+            }
+
+            const result = await target[prop].apply(target, args);
+
+            // Return based on returnType setting
+            if (self.returnType === 'data' && result && typeof result === 'object' && 'data' in result) {
+              return result.data;
+            }
+            if (self.returnType === 'data' && result && typeof result === 'object' && 'error' in result) {
+              const error = new Error(result.error.error.message || result.error.error.code || 'Unknown error') as any;
+              if (result.error.error.details) {
+                error.details = result.error.error.details;
+              }
+              throw error;
+            }
+            // Return raw response (default behavior)
+            return result;
+          };
+        }
+        return target[prop];
+      }
+    });
+  }
+
+  // Manual login method (optional, for explicit control)
+  async manualLogin(): Promise<boolean> {
+    return this.login();
+  }
+}
+
+// Legacy function for backward compatibility
+const configure = (options: {
+  baseURL: string;
+  email?: string;
+  username?: string;
+  password: string;
+  returnType?: 'raw' | 'data';
+}) => {
+  return new NextPlusSDK(options);
+};
+
+// Create SDK instance
+const createSDK = (options: {
+  baseURL: string;
+  email?: string;
+  username?: string;
+  password: string;
+  returnType?: 'raw' | 'data';
+}) => {
+  return new NextPlusSDK(options);
+};
+
+export { configure, createSDK, NextPlusSDK };

package/src/sdk/client/client.gen.ts

@@ -0,0 +1,199 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Config, ResolvedRequestOptions } from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<
+    Request,
+    Response,
+    unknown,
+    ResolvedRequestOptions
+  >();
+
+  const request: Client['request'] = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.serializedBody === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const url = buildUrl(opts);
+    const requestInit: ReqInit = {
+      redirect: 'follow',
+      ...opts,
+      body: opts.serializedBody,
+    };
+
+    let request = new Request(url, requestInit);
+
+    for (const fn of interceptors.request._fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!;
+    let response = await _fetch(request);
+
+    for (const fn of interceptors.response._fns) {
+      if (fn) {
+        response = await fn(response, request, opts);
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    };
+
+    if (response.ok) {
+      if (
+        response.status === 204 ||
+        response.headers.get('Content-Length') === '0'
+      ) {
+        return opts.responseStyle === 'data'
+          ? {}
+          : {
+              data: {},
+              ...result,
+            };
+      }
+
+      const parseAs =
+        (opts.parseAs === 'auto'
+          ? getParseAs(response.headers.get('Content-Type'))
+          : opts.parseAs) ?? 'json';
+
+      let data: any;
+      switch (parseAs) {
+        case 'arrayBuffer':
+        case 'blob':
+        case 'formData':
+        case 'json':
+        case 'text':
+          data = await response[parseAs]();
+          break;
+        case 'stream':
+          return opts.responseStyle === 'data'
+            ? response.body
+            : {
+                data: response.body,
+                ...result,
+              };
+      }
+
+      if (parseAs === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? data
+        : {
+            data,
+            ...result,
+          };
+    }
+
+    const textError = await response.text();
+    let jsonError: unknown;
+
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError;
+    let finalError = error;
+
+    for (const fn of interceptors.error._fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string;
+      }
+    }
+
+    finalError = finalError || ({} as string);
+
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === 'data'
+      ? undefined
+      : {
+          error: finalError,
+          ...result,
+        };
+  };
+
+  return {
+    buildUrl,
+    connect: (options) => request({ ...options, method: 'CONNECT' }),
+    delete: (options) => request({ ...options, method: 'DELETE' }),
+    get: (options) => request({ ...options, method: 'GET' }),
+    getConfig,
+    head: (options) => request({ ...options, method: 'HEAD' }),
+    interceptors,
+    options: (options) => request({ ...options, method: 'OPTIONS' }),
+    patch: (options) => request({ ...options, method: 'PATCH' }),
+    post: (options) => request({ ...options, method: 'POST' }),
+    put: (options) => request({ ...options, method: 'PUT' }),
+    request,
+    setConfig,
+    trace: (options) => request({ ...options, method: 'TRACE' }),
+  };
+};

package/src/sdk/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  OptionsLegacyParser,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

package/src/sdk/client/types.gen.ts

@@ -0,0 +1,232 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth } from '../core/auth.gen';
+import type {
+  Client as CoreClient,
+  Config as CoreConfig,
+} from '../core/types.gen';
+import type { Middleware } from './utils.gen';
+
+export type ResponseStyle = 'data' | 'fields';
+
+export interface Config<T extends ClientOptions = ClientOptions>
+  extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
+    CoreConfig {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: (request: Request) => ReturnType<typeof fetch>;
+  /**
+   * Please don't use the Fetch client for Next.js applications. The `next`
+   * options won't have any effect.
+   *
+   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+   */
+  next?: never;
+  /**
+   * Return the response data parsed in a specified format. By default, `auto`
+   * will infer the appropriate method from the `Content-Type` response header.
+   * You can override this behavior with any of the {@link Body} methods.
+   * Select `stream` if you don't want to parse response data at all.
+   *
+   * @default 'auto'
+   */
+  parseAs?:
+    | 'arrayBuffer'
+    | 'auto'
+    | 'blob'
+    | 'formData'
+    | 'json'
+    | 'stream'
+    | 'text';
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
+}
+
+export interface RequestOptions<
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string,
+> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+  }> {
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
+}
+
+export interface ResolvedRequestOptions<
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string,
+> extends RequestOptions<TResponseStyle, ThrowOnError, Url> {
+  serializedBody?: string;
+}
+
+export type RequestResult<
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = ThrowOnError extends true
+  ? Promise<
+      TResponseStyle extends 'data'
+        ? TData extends Record<string, unknown>
+          ? TData[keyof TData]
+          : TData
+        : {
+            data: TData extends Record<string, unknown>
+              ? TData[keyof TData]
+              : TData;
+            request: Request;
+            response: Response;
+          }
+    >
+  : Promise<
+      TResponseStyle extends 'data'
+        ?
+            | (TData extends Record<string, unknown>
+                ? TData[keyof TData]
+                : TData)
+            | undefined
+        : (
+            | {
+                data: TData extends Record<string, unknown>
+                  ? TData[keyof TData]
+                  : TData;
+                error: undefined;
+              }
+            | {
+                data: undefined;
+                error: TError extends Record<string, unknown>
+                  ? TError[keyof TError]
+                  : TError;
+              }
+          ) & {
+            request: Request;
+            response: Response;
+          }
+    >;
+
+export interface ClientOptions {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle;
+  throwOnError?: boolean;
+}
+
+type MethodFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'>,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type RequestFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'> &
+    Pick<Required<RequestOptions<TResponseStyle, ThrowOnError>>, 'method'>,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type BuildUrlFn = <
+  TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+  },
+>(
+  options: Pick<TData, 'url'> & Options<TData>,
+) => string;
+
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
+  override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
+
+export interface TDataShape {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
+}
+
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export type Options<
+  TData extends TDataShape = TDataShape,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = OmitKeys<
+  RequestOptions<TResponseStyle, ThrowOnError>,
+  'body' | 'path' | 'query' | 'url'
+> &
+  Omit<TData, 'url'>;
+
+export type OptionsLegacyParser<
+  TData = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = TData extends { body?: any }
+  ? TData extends { headers?: any }
+    ? OmitKeys<
+        RequestOptions<TResponseStyle, ThrowOnError>,
+        'body' | 'headers' | 'url'
+      > &
+        TData
+    : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'body' | 'url'> &
+        TData &
+        Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'headers'>
+  : TData extends { headers?: any }
+    ? OmitKeys<
+        RequestOptions<TResponseStyle, ThrowOnError>,
+        'headers' | 'url'
+      > &
+        TData &
+        Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'body'>
+    : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'url'> & TData;