@nextplus/js-sdk 0.0.12 → 1.14.46

package/dist/smoke.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/smoke.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/smoke.js

@@ -0,0 +1,79 @@
+import {
+  configure
+} from "./chunk-SUTLUR6L.js";
+import "./chunk-UNVS4USV.js";
+import "./chunk-SFE3EXIE.js";
+import "./chunk-FXXZNC42.js";
+
+// src/smoke.ts
+async function main() {
+  console.log("=== Testing with email and returnType: data ===");
+  const sdk = configure({
+    baseURL: "http://127.0.0.1:3000/api",
+    email: "operator@operator.com",
+    password: "operator@operator.com",
+    returnType: "data"
+    // Only return data, not full response
+  });
+  console.log("SDK configured (email)");
+  const tables = await sdk.TableService.find({
+    query: {
+      filter: JSON.stringify({
+        language: "he",
+        limit: 10,
+        order: "created DESC",
+        fields: {
+          id: true,
+          name: true,
+          created: true
+        },
+        where: {
+          name: "no-such-table!"
+        }
+      })
+    }
+  });
+  console.log(
+    "Tables found (data only):",
+    Array.isArray(tables) ? `Array with ${tables.length} items` : tables
+  );
+  try {
+    const newTable = await sdk.TableService.create({ body: {} });
+    console.log("New table created:", newTable);
+  } catch (error) {
+    console.log("Expected validation error caught:", error.message);
+  }
+  console.log("\n=== Testing with username and returnType: raw ===");
+  const sdk2 = configure({
+    baseURL: "http://127.0.0.1:3000/api",
+    username: "operator",
+    // Using username instead of email
+    password: "operator@operator.com",
+    returnType: "raw"
+    // Return full response object
+  });
+  console.log("SDK configured (username)");
+  const tablesRaw = await sdk2.TableService.find({
+    query: {
+      filter: JSON.stringify({
+        where: {
+          name: "test"
+        },
+        limit: 5
+      })
+    }
+  });
+  console.log("Tables found (raw response):", {
+    hasData: "data" in tablesRaw,
+    hasRequest: "request" in tablesRaw,
+    hasResponse: "response" in tablesRaw,
+    dataLength: tablesRaw.data ? tablesRaw.data.length : "no data"
+  });
+  try {
+    const createTable = await sdk2.TableService.create({ body: {} });
+    console.log("Table created:", createTable);
+  } catch (error) {
+    console.log("Expected validation error caught (raw mode):", error.message);
+  }
+}
+main().catch(console.error);

package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "@nextplus/js-sdk",
-  "version": "0.0.12",
+  "version": "1.14.46",
   "type": "module",
   "scripts": {
     "generate": "npm run clean && npm run prepare-spec && npm run openapi-ts && npm run build",
-    "build": "tsup",
+    "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",
     "clean": "rm -rf dist && rm -rf .generated",
-    "prepublishOnly": "npm run clean && SKIP_SMOKE=1 tsup",
+    "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",
     "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 --test dist/smoke.js",
-    "test:watch": "tsx watch --test src/smoke.ts",
-    "test:dev": "tsx --test src/smoke.ts"
+    "test": "npm run build && node dist/smoke.js"
   },
   "files": [
     "dist",
@@ -26,11 +24,6 @@
       "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",
@@ -59,7 +52,6 @@
     "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,43 +1,18 @@
 import debug from 'debug';
-import { createClient, createConfig } from './sdk/client';
+import { createClient } 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;
@@ -59,18 +34,17 @@ const isTokenValid = (): boolean => {
   return tokenAge < tokenTtlMs;
 };
 
+
+
 export class NextPlusSDK {
-  public client: any; // Exposed for tree-shakeable service imports
-  private credentials?: { email?: string; username?: string; password: string };
-  private providedAccessToken?: string;
+  private client: any;
+  private credentials: { email?: string; username?: string; password: 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
@@ -80,22 +54,10 @@ 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) {
@@ -111,13 +73,9 @@ 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]);
@@ -127,8 +85,7 @@ 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) {
@@ -142,8 +99,7 @@ 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];
           });
         }
       }
@@ -162,83 +118,41 @@ export class NextPlusSDK {
     return options;
   }
 
-  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',
-      );
+  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 (!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,
-      };
+    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';
-
-    // 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');
-      }
-    }
-
-    // Normalize baseURL
-    if (baseURL.endsWith('/')) {
-      baseURL = baseURL.slice(0, -1);
+    // remove trailing slash from baseURL
+    if (options.baseURL.endsWith('/')) {
+      options.baseURL = options.baseURL.slice(0, -1);
     }
-    if (!baseURL.endsWith('/api')) {
-      baseURL = baseURL + '/api';
+    // if baseURL does not end with /api, add it
+    if (!options.baseURL.endsWith('/api')) {
+      options.baseURL = options.baseURL + '/api';
     }
-
-    this.client = createClient(
-      createConfig({
-        baseUrl: baseURL,
-        throwOnError: options.throwOnError ?? false,
-      }),
-    );
+    this.client = createClient({
+      baseUrl: options.baseURL,
+    });
 
     // 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();
@@ -250,37 +164,24 @@ export class NextPlusSDK {
       return request;
     }
 
-    // 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);
-      }
-    }
+    // 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> {
-    // Only validate token for credentials mode
-    if (this.authMode === 'credentials' && !isTokenValid()) {
+    if (!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,
@@ -318,13 +219,11 @@ 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
@@ -337,7 +236,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
@@ -347,25 +246,11 @@ 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;
               }
@@ -376,111 +261,46 @@ export class NextPlusSDK {
           };
         }
         return target[prop];
-      },
+      }
     });
   }
 
-  // Manual login method (optional, for explicit control in credentials mode)
+  // Manual login method (optional, for explicit control)
   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 {}
 
-// SDK instance type
+// Legacy function for backward compatibility
 type SDKInstance = NextPlusSDK & ServiceStatics;
 
-// 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;
+const configure = (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;
+// Create SDK instance
+const createSDK = (options: {
+  baseURL: string;
+  email?: string;
+  username?: string;
+  password: string;
+  returnType?: 'raw' | 'data';
+}): SDKInstance => {
+  return new NextPlusSDK(options) as SDKInstance;
 };
 
-// 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';