@nextplus/js-sdk 0.0.10 → 0.0.12

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@nextplus/js-sdk",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "scripts": {
     "generate": "npm run clean && npm run prepare-spec && npm run openapi-ts && npm run build",
-    "build": "tsup src/index.ts src/sdk/index.ts src/sdk/client/index.ts src/sdk/sdk.gen.ts src/smoke.ts --dts --format esm,cjs --outDir dist --clean",
+    "build": "tsup",
     "clean": "rm -rf dist && rm -rf .generated",
-    "prepublishOnly": "npm run clean && tsup src/index.ts src/sdk/index.ts src/sdk/client/index.ts src/sdk/sdk.gen.ts --dts --format esm,cjs --outDir dist --clean",
+    "prepublishOnly": "npm run clean && SKIP_SMOKE=1 tsup",
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
     "openapi-ts": "openapi-ts",
     "prepare-spec": "node scripts/prepare-spec.js",
-    "test": "npm run build && node dist/smoke.js"
+    "test": "npm run build && node --test dist/smoke.js",
+    "test:watch": "tsx watch --test src/smoke.ts",
+    "test:dev": "tsx --test src/smoke.ts"
   },
   "files": [
     "dist",
@@ -24,6 +26,11 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./services": {
+      "types": "./dist/sdk/sdk.gen.d.ts",
+      "import": "./dist/sdk/sdk.gen.js",
+      "require": "./dist/sdk/sdk.gen.cjs"
+    },
     "./sdk": {
       "types": "./dist/sdk/index.d.ts",
       "import": "./dist/sdk/index.js",
@@ -52,6 +59,7 @@
     "eslint": "^9.32.0",
     "prettier": "^3.6.2",
     "tsup": "^8.5.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.2"
   },
   "dependencies": {

package/src/index.ts

@@ -1,18 +1,43 @@
 import debug from 'debug';
-import { createClient } from './sdk/client';
+import { createClient, createConfig } from './sdk/client';
 import { UserModelService } from './sdk';
 import * as AllServices from './sdk';
 import type * as AllServiceTypes from './sdk';
 
 const log = debug('nextplus:sdk');
 
+// Configuration types for token-based authentication
+export type TokenConfig = {
+  baseURL?: string;
+  accessToken: string;
+  returnType?: 'raw' | 'data';
+  throwOnError?: boolean; // For tree-shakeable imports
+};
+
+// Configuration types for credential-based authentication
+export type CredentialConfig = {
+  baseURL?: string;
+  email?: string;
+  username?: string;
+  password: string;
+  returnType?: 'raw' | 'data';
+  throwOnError?: boolean; // For tree-shakeable imports
+};
+
+// Union type for SDK configuration
+export type SDKConfig = TokenConfig | CredentialConfig;
+
 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) => {
+const setAccessToken = (
+  token: string,
+  created: Date = new Date(),
+  ttl: number = 1209600,
+) => {
   accessToken.token = token;
   accessToken.created = created;
   accessToken.ttl = ttl;
@@ -34,17 +59,18 @@ const isTokenValid = (): boolean => {
   return tokenAge < tokenTtlMs;
 };
 
-
-
 export class NextPlusSDK {
-  private client: any;
-  private credentials: { email?: string; username?: string; password: string };
+  public client: any; // Exposed for tree-shakeable service imports
+  private credentials?: { email?: string; username?: string; password: string };
+  private providedAccessToken?: string;
   private returnType: 'raw' | 'data' = 'data';
+  private authMode: 'token' | 'credentials';
 
   // Wrap plain developer inputs into the right container (body/query)
   // and stringify complex query params when required by LoopBack (filter/where)
   private normalizeOptions(methodName: string, rawOptions: any): any {
-    const options: any = rawOptions && typeof rawOptions === 'object' ? { ...rawOptions } : {};
+    const options: any =
+      rawOptions && typeof rawOptions === 'object' ? { ...rawOptions } : {};
 
     // Always ensure client is set (will be set by caller afterwards if missing)
     // We avoid mutating the original object to keep predictable behavior
@@ -54,10 +80,22 @@ export class NextPlusSDK {
     const method = methodName.toString().toLowerCase();
     const isFind = method.includes('find') && !method.includes('count');
     const isCount = method.includes('count');
-    const shouldUseBody = /(create|update|replace|patch|login|upsert)/i.test(methodName.toString());
+    const shouldUseBody = /(create|update|replace|patch|login|upsert)/i.test(
+      methodName.toString(),
+    );
 
-    const topLevelKeys = ['filter', 'where', 'fields', 'order', 'limit', 'offset', 'include'];
-    const hasTopLevelFilterBits = topLevelKeys.some((k) => Object.prototype.hasOwnProperty.call(options, k));
+    const topLevelKeys = [
+      'filter',
+      'where',
+      'fields',
+      'order',
+      'limit',
+      'offset',
+      'include',
+    ];
+    const hasTopLevelFilterBits = topLevelKeys.some((k) =>
+      Object.prototype.hasOwnProperty.call(options, k),
+    );
 
     // Only create query if relevant for this method
     if (isFind) {
@@ -73,9 +111,13 @@ export class NextPlusSDK {
         if (options.order !== undefined) filterObject.order = options.order;
         if (options.limit !== undefined) filterObject.limit = options.limit;
         if (options.offset !== undefined) filterObject.offset = options.offset;
-        if (options.include !== undefined) filterObject.include = options.include;
+        if (options.include !== undefined)
+          filterObject.include = options.include;
         if (Object.keys(filterObject).length > 0) {
-          options.query.filter = typeof filterObject === 'string' ? filterObject : JSON.stringify(filterObject);
+          options.query.filter =
+            typeof filterObject === 'string'
+              ? filterObject
+              : JSON.stringify(filterObject);
         }
         // Clean moved keys from top-level
         topLevelKeys.forEach((k) => delete options[k]);
@@ -85,7 +127,8 @@ export class NextPlusSDK {
       // Allow top-level where or query.where as object → stringify
       if (options.where !== undefined) {
         const whereVal = options.where;
-        options.query.where = typeof whereVal === 'string' ? whereVal : JSON.stringify(whereVal);
+        options.query.where =
+          typeof whereVal === 'string' ? whereVal : JSON.stringify(whereVal);
         delete options.where;
       }
     } else if (shouldUseBody) {
@@ -99,7 +142,8 @@ export class NextPlusSDK {
           options.body = bodyCandidate;
           // Keep only body/client/query/path at root
           Object.keys(options).forEach((k) => {
-            if (!['body', 'client', 'query', 'path'].includes(k)) delete options[k];
+            if (!['body', 'client', 'query', 'path'].includes(k))
+              delete options[k];
           });
         }
       }
@@ -118,41 +162,83 @@ export class NextPlusSDK {
     return options;
   }
 
-  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');
+  constructor(options: SDKConfig) {
+    // Determine authentication mode
+    const hasToken = 'accessToken' in options && options.accessToken;
+    const hasPassword = 'password' in options && options.password;
+
+    // Validate mutually exclusive authentication
+    if (hasToken && hasPassword) {
+      throw new Error(
+        'Provide either accessToken or credentials (email/username + password), not both',
+      );
     }
-    if (options.email && options.username) {
-      throw new Error('Provide either email or username, not both');
+
+    if (!hasToken && !hasPassword) {
+      throw new Error(
+        'Either accessToken or credentials (email/username + password) must be provided',
+      );
+    }
+
+    // Set authentication mode
+    if (hasToken) {
+      this.authMode = 'token';
+      this.providedAccessToken = (options as TokenConfig).accessToken;
+      // Set the token immediately for token-based auth
+      setAccessToken(this.providedAccessToken, new Date(), 1209600);
+    } else {
+      this.authMode = 'credentials';
+      const credConfig = options as CredentialConfig;
+
+      // Validate that either email or username is provided
+      if (!credConfig.email && !credConfig.username) {
+        throw new Error(
+          'Either email or username must be provided with password',
+        );
+      }
+      if (credConfig.email && credConfig.username) {
+        throw new Error('Provide either email or username, not both');
+      }
+
+      this.credentials = {
+        email: credConfig.email,
+        username: credConfig.username,
+        password: credConfig.password,
+      };
     }
 
-    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);
+
+    // Handle baseURL with smart defaults
+    let baseURL = options.baseURL;
+    if (!baseURL) {
+      // Try to detect browser environment
+      if (typeof window !== 'undefined' && window.location) {
+        baseURL = window.location.origin + '/api';
+      } else {
+        throw new Error('baseURL is required in non-browser environments');
+      }
     }
-    // if baseURL does not end with /api, add it
-    if (!options.baseURL.endsWith('/api')) {
-      options.baseURL = options.baseURL + '/api';
+
+    // Normalize baseURL
+    if (baseURL.endsWith('/')) {
+      baseURL = baseURL.slice(0, -1);
     }
-    this.client = createClient({
-      baseUrl: options.baseURL,
-    });
+    if (!baseURL.endsWith('/api')) {
+      baseURL = baseURL + '/api';
+    }
+
+    this.client = createClient(
+      createConfig({
+        baseUrl: baseURL,
+        throwOnError: options.throwOnError ?? false,
+      }),
+    );
 
     // Add authentication interceptor
-    this.client.interceptors.request.use(this.authRequestInterceptor.bind(this));
+    this.client.interceptors.request.use(
+      this.authRequestInterceptor.bind(this),
+    );
 
     // Create service proxies dynamically
     this.createServiceProxies();
@@ -164,24 +250,37 @@ export class NextPlusSDK {
       return request;
     }
 
-    // Ensure we have a valid token
-    await this.ensureValidToken();
-
-    const token = getAccessToken();
-    if (token.token) {
-      request.headers.set('Authorization', token.token);
+    // Handle authentication based on mode
+    if (this.authMode === 'token') {
+      // For token mode, use the provided token directly
+      if (this.providedAccessToken) {
+        request.headers.set('Authorization', this.providedAccessToken);
+      }
+    } else {
+      // For credentials mode, 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()) {
+    // Only validate token for credentials mode
+    if (this.authMode === 'credentials' && !isTokenValid()) {
       log('Token expired or missing, refreshing...');
       await this.login();
     }
   }
 
   private async login(): Promise<boolean> {
+    if (this.authMode !== 'credentials' || !this.credentials) {
+      throw new Error('Login is only available in credentials mode');
+    }
+
     try {
       const loginBody: any = {
         password: this.credentials.password,
@@ -219,11 +318,13 @@ export class NextPlusSDK {
 
   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'
+    const serviceNames = Object.keys(AllServices).filter(
+      (key) =>
+        key.endsWith('Service') &&
+        typeof (AllServices as any)[key] === 'function',
     );
 
-    serviceNames.forEach(serviceName => {
+    serviceNames.forEach((serviceName) => {
       const ServiceClass = (AllServices as any)[serviceName];
 
       // Create a proxy for each service
@@ -236,7 +337,7 @@ export class NextPlusSDK {
     return new Proxy(ServiceClass, {
       get(target, prop) {
         if (typeof target[prop] === 'function') {
-          return async function(...args: any[]) {
+          return async function (...args: any[]) {
             // Automatically inject client if not provided
             if (!args[0]) args[0] = {};
             // Normalize developer-friendly input into OpenAPI options
@@ -246,11 +347,25 @@ export class NextPlusSDK {
             const result = await target[prop].apply(target, args);
 
             // Return based on returnType setting
-            if (self.returnType === 'data' && result && typeof result === 'object' && 'data' in result) {
+            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 (
+              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;
               }
@@ -261,46 +376,111 @@ export class NextPlusSDK {
           };
         }
         return target[prop];
-      }
+      },
     });
   }
 
-  // Manual login method (optional, for explicit control)
+  // Manual login method (optional, for explicit control in credentials mode)
   async manualLogin(): Promise<boolean> {
+    if (this.authMode !== 'credentials') {
+      throw new Error('manualLogin is only available in credentials mode');
+    }
     return this.login();
   }
+
+  // Bind a service to this SDK's client for tree-shakeable imports
+  // This eliminates the need to pass client on every call
+  service<T extends Record<string, any>>(ServiceClass: T): T {
+    const client = this.client;
+    const boundService = Object.create(ServiceClass);
+
+    // Get all property names including static methods
+    const properties = Object.getOwnPropertyNames(ServiceClass);
+
+    properties.forEach((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(ServiceClass, key);
+      if (
+        descriptor &&
+        typeof descriptor.value === 'function' &&
+        key !== 'constructor'
+      ) {
+        // Bind static methods to auto-inject client
+        boundService[key] = (options: any = {}) => {
+          return descriptor.value.call(ServiceClass, { ...options, client });
+        };
+      }
+    });
+
+    return boundService;
+  }
 }
 
 // Expose accurate static service method types on the SDK instance for IDE/type safety
 type ServiceStatics = {
-  [K in keyof typeof AllServiceTypes as K extends `${string}Service` ? K : never]: typeof AllServiceTypes[K];
+  [K in keyof typeof AllServiceTypes as K extends `${string}Service`
+    ? K
+    : never]: (typeof AllServiceTypes)[K];
 };
 
 export interface NextPlusSDK extends ServiceStatics {}
 
-// Legacy function for backward compatibility
+// SDK instance type
 type SDKInstance = NextPlusSDK & ServiceStatics;
 
-const configure = (options: {
-  baseURL: string;
-  email?: string;
-  username?: string;
-  password: string;
-  returnType?: 'raw' | 'data';
-}): SDKInstance => {
-  return new NextPlusSDK(options) as SDKInstance;
+// Import the generated default client to update it
+import { client as generatedClient } from './sdk/client.gen';
+
+// Configure function - creates a full SDK instance with service proxies
+// Automatically sets the client as global default for tree-shakeable imports
+const configure = (options: SDKConfig): SDKInstance => {
+  const sdk = new NextPlusSDK(options) as SDKInstance;
+  // Automatically set as global default
+  setDefaultClient(sdk.client);
+  // Update the generated SDK's default client so services work without passing client
+  Object.assign(generatedClient, sdk.client);
+  return sdk;
 };
 
-// Create SDK instance
-const createSDK = (options: {
-  baseURL: string;
-  email?: string;
-  username?: string;
-  password: string;
-  returnType?: 'raw' | 'data';
-}): SDKInstance => {
-  return new NextPlusSDK(options) as SDKInstance;
+// Create SDK instance - alias for configure
+const createSDK = (options: SDKConfig): SDKInstance => {
+  const sdk = new NextPlusSDK(options) as SDKInstance;
+  // Automatically set as global default
+  setDefaultClient(sdk.client);
+  // Update the generated SDK's default client so services work without passing client
+  Object.assign(generatedClient, sdk.client);
+  return sdk;
 };
 
+// Global default client for tree-shakeable imports
+// Automatically set when configure() or createSDK() is called
+let globalClient: any = null;
+
+/**
+ * Set a global default client for all service calls
+ * Note: This is automatically called by configure() and createSDK()
+ * You usually don't need to call this manually
+ */
+export function setDefaultClient(client: any): void {
+  globalClient = client;
+}
+
+/**
+ * Get the current global default client
+ */
+export function getDefaultClient(): any {
+  return globalClient;
+}
+
+/**
+ * Clear the global default client (useful for logout)
+ */
+export function clearDefaultClient(): void {
+  globalClient = null;
+}
+
 export type { SDKInstance };
 export { configure, createSDK };
+
+// Re-export SDK types and generated services
+// Services will automatically use global client as fallback via the generated code's default client
+export * from './sdk';