Smart Tables SDK

npm install @odin-ai-staging/sdk

import { SmartTablesSDK } from '@odin-ai-staging/sdk';

// SDK को आरंभ करें
const smartTablesSDK = new SmartTablesSDK({
  baseUrl: 'https://your-api-endpoint.com/',
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
  apiSecret: 'your-api-secret'
});

// त्वरित उदाहरण: तालिका बनाएँ और डेटा जोड़ें
async function quickExample() {
  // एक नई तालिका बनाएँ
  const table = await smartTablesSDK.createTable(
    'ग्राहक डेटाबेस',
    'ग्राहक जानकारी प्रबंधित करें'
  );
  
  // कॉलम जोड़ें
  await smartTablesSDK.addColumn(table.id, {
    name: 'name',
    type: 'text',
    description: 'ग्राहक का नाम'
  });
  
  await smartTablesSDK.addColumn(table.id, {
    name: 'email',
    type: 'email',
    description: 'ग्राहक ईमेल पता'
  });
  
  // डेटा जोड़ें
  await smartTablesSDK.addRow(table.id, {
    name: 'जॉन डो',
    email: 'john@example.com'
  });
  
  // डेटा क्वेरी करें
  const results = await smartTablesSDK.queryTable(table.id, {
    filters: [{ column: 'name', operator: 'contains', value: 'जॉन' }],
    pagination: { limit: 10, page: 1 }
  });
  
  console.log('क्वेरी परिणाम:', results.data);
}

interface SmartTablesSDKConfig {
  baseUrl: string;          // API एंडपॉइंट URL
  projectId: string;        // आपका परियोजना पहचानकर्ता
  apiKey?: string;          // प्रमाणीकरण के लिए API key
  apiSecret?: string;       // प्रमाणीकरण के लिए API secret
  accessToken?: string;     // वेब ऐप उपयोग के लिए access token
}

interface SmartTable {
  id: string;                    // अद्वितीय तालिका पहचानकर्ता
  project_id: string;            // यह तालिका किस परियोजना से संबंधित है
  title: string;                 // तालिका का प्रदर्शन नाम
  description: string;           // तालिका विवरण
  schema: SmartTableColumn[];    // कॉलम परिभाषाएँ
  table_name: string;           // आंतरिक तालिका नाम
  created_at?: number;          // निर्माण टाइमस्टैम्प
  updated_at?: number;          // अंतिम अपडेट टाइमस्टैम्प
}

interface SmartTableColumn {
  name: string;                           // कॉलम नाम
  type: ColumnType;                       // डेटा प्रकार
  description?: string;                   // कॉलम विवरण
  notNull?: boolean;                      // आवश्यक फ़ील्ड
  unique?: boolean;                       // अद्वितीय बाध्यता
  defaultValue?: string | number | boolean | null;  // डिफ़ॉल्ट मान
  options?: Record<string, unknown>;      // अतिरिक्त विकल्प
}

type ColumnType = 'text' | 'number' | 'boolean' | 'date' | 'email' | 'url' | 'json';

interface TableFilter {
  column: string;
  operator: FilterOperator;
  value: string | number | boolean | null;
}

type FilterOperator = 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains' | 'startswith' | 'endswith';

interface TableSort {
  column: string;
  direction: 'asc' | 'desc';
}

interface TablePagination {
  page?: number;
  limit?: number;
  search?: string;
}

async getAllTables(): Promise<SmartTable[]>

const tables = await smartTablesSDK.getAllTables();
tables.forEach(table => {
  console.log(`तालिका: ${table.title} (${table.id})`);
  console.log(`कॉलम: ${table.schema.length}`);
});

async getTable(tableId: string): Promise<SmartTable>

const table = await smartTablesSDK.getTable('table_123');
console.log('तालिका स्कीमा:', table.schema);

async createTable(
  title: string,
  description: string,
  metadata?: Record<string, unknown>
): Promise<SmartTable>

const table = await smartTablesSDK.createTable(
  'उत्पाद कैटलॉग',
  'उत्पाद जानकारी और इन्वेंट्री प्रबंधित करें',
  { category: 'inventory', owner: 'admin' }
);

async updateTable(
  tableId: string,
  title: string,
  description?: string,
  metadata?: Record<string, unknown>
): Promise<void>

await smartTablesSDK.updateTable(
  'table_123',
  'अपडेटेड उत्पाद कैटलॉग',
  'उन्नत उत्पाद प्रबंधन प्रणाली',
  { version: '2.0' }
);

async deleteTable(tableId: string): Promise<void>

await smartTablesSDK.deleteTable('table_123');

async addColumn(tableId: string, column: SmartTableColumn): Promise<void>

await smartTablesSDK.addColumn('table_123', {
  name: 'product_name',
  type: 'text',
  description: 'उत्पाद का नाम',
  notNull: true
});

await smartTablesSDK.addColumn('table_123', {
  name: 'price',
  type: 'number',
  description: 'USD में उत्पाद मूल्य',
  defaultValue: 0,
  notNull: true
});

await smartTablesSDK.addColumn('table_123', {
  name: 'supplier_email',
  type: 'email',
  description: 'आपूर्तिकर्ता संपर्क ईमेल',
  unique: true
});

async updateColumn(
  tableId: string,
  columnName: string,
  updates: Partial<SmartTableColumn>
): Promise<void>

await smartTablesSDK.updateColumn('table_123', 'product_name', {
  description: 'अपडेटेड उत्पाद नाम फ़ील्ड',
  notNull: true,
  unique: true
});

async deleteColumn(tableId: string, columnName: string): Promise<void>

await smartTablesSDK.deleteColumn('table_123', 'obsolete_column');

async addRow(tableId: string, data: Record<string, any>): Promise<any>

const newRow = await smartTablesSDK.addRow('table_123', {
  product_name: 'वायरलेस हेडफोन',
  price: 99.99,
  supplier_email: 'supplier@example.com',
  in_stock: true
});

console.log('नई पंक्ति ID:', newRow.id);

async updateRow(
  tableId: string,
  rowId: string,
  columnName: string,
  newValue: any
): Promise<void>

await smartTablesSDK.updateRow(
  'table_123',
  'row_456',
  'price',
  89.99
);

await smartTablesSDK.updateRow(
  'table_123',
  'row_456',
  'in_stock',
  false
);

async deleteRow(tableId: string, rowId: string): Promise<void>

await smartTablesSDK.deleteRow('table_123', 'row_456');

async queryTable(
  tableId: string,
  options?: TableQueryOptions
): Promise<TableQueryResponse>

interface TableQueryOptions {
  filters?: TableFilter[];      // फ़िल्टर शर्तें
  sort?: TableSort[];          // सॉर्ट कॉन्फ़िगरेशन
  pagination?: TablePagination; // पेजिनेशन सेटिंग्स
}

const results = await smartTablesSDK.queryTable('table_123');
console.log('सभी डेटा:', results.data);

const results = await smartTablesSDK.queryTable('table_123', {
  filters: [
    { column: 'price', operator: 'gte', value: 50 },
    { column: 'in_stock', operator: 'eq', value: true },
    { column: 'product_name', operator: 'contains', value: 'headphones' }
  ]
});

const results = await smartTablesSDK.queryTable('table_123', {
  sort: [
    { column: 'price', direction: 'desc' },
    { column: 'product_name', direction: 'asc' }
  ],
  pagination: {
    page: 2,
    limit: 20,
    search: 'wireless'
  }
});

console.log(`${results.total} आइटम मिले`);
console.log(`पेज ${results.page} / ${Math.ceil(results.total / results.limit)}`);

async importTable(
  title: string,
  description: string,
  columnMappings: ColumnMapping[],
  file: File
): Promise<ImportResult>

interface ColumnMapping {
  sourceColumn: string;     // स्रोत फ़ाइल में कॉलम नाम
  targetColumn: string;     // लक्ष्य तालिका में कॉलम नाम
  dataType: string;         // लक्ष्य डेटा प्रकार
}

const fileInput = document.getElementById('csvFile') as HTMLInputElement;
const file = fileInput.files[0];

const columnMappings: ColumnMapping[] = [
  { sourceColumn: 'Name', targetColumn: 'product_name', dataType: 'text' },
  { sourceColumn: 'Price', targetColumn: 'price', dataType: 'number' },
  { sourceColumn: 'Email', targetColumn: 'supplier_email', dataType: 'email' }
];

const result = await smartTablesSDK.importTable(
  'आयातित उत्पाद',
  'CSV से आयातित उत्पाद',
  columnMappings,
  file
);

console.log(`${result.rows_imported} पंक्तियाँ आयातित`);
console.log(`तालिका ID: ${result.data_type_id}`);

async computeRowColumns(
  dataTypeId: string,
  rowId: string,
  columnNames?: string[]
): Promise<void>

await smartTablesSDK.computeRowColumns(
  'table_123',
  'row_456',
  ['ai_summary', 'sentiment_score']
);

async computeAllRows(dataTypeId: string): Promise<{
  message: string;
  total_rows_processed: number;
  total_columns_updated: number;
  updated_columns: string[];
  failed_rows: number[];
  stopped_due_to_failures: boolean;
  retry_attempts: Record<number, number>;
  computation_id?: string;
  history_table?: string;
}>

const result = await smartTablesSDK.computeAllRows('table_123');
console.log(`${result.total_rows_processed} पंक्तियाँ प्रोसेस`);
console.log(`${result.total_columns_updated} कॉलम अपडेट`);
console.log(`अपडेटेड कॉलम: ${result.updated_columns.join(', ')}`);

if (result.failed_rows.length > 0) {
  console.log(`विफल पंक्तियाँ: ${result.failed_rows.join(', ')}`);
}

try {
  const table = await smartTablesSDK.createTable('मेरी तालिका', 'विवरण');
} catch (error) {
  if (error instanceof APIError) {
    console.error(`API त्रुटि ${error.status}: ${error.message}`);
    if (error.detail) {
      console.error('विवरण:', error.detail);
    }
  } else {
    console.error('अप्रत्याशित त्रुटि:', error);
  }
}

import { SmartTablesSDK } from '@odin-ai-staging/sdk';

class ProductManager {
  private sdk: SmartTablesSDK;
  private tableId?: string;

  constructor() {
    this.sdk = new SmartTablesSDK({
      baseUrl: process.env.API_BASE_URL,
      projectId: process.env.PROJECT_ID,
      apiKey: process.env.API_KEY,
      apiSecret: process.env.API_SECRET
    });
  }

  async initializeTable() {
    try {
      const table = await this.sdk.createTable(
        'उत्पाद कैटलॉग',
        'उत्पाद इन्वेंट्री और जानकारी प्रबंधित करें'
      );
      this.tableId = table.id;
      await this.addColumns();
      console.log('तालिका आरंभ:', this.tableId);
      return table;
    } catch (error) {
      console.error('तालिका आरंभ करने में विफल:', error);
      throw error;
    }
  }

  private async addColumns() {
    const columns = [
      { name: 'name', type: 'text', description: 'उत्पाद का नाम', notNull: true },
      { name: 'description', type: 'text', description: 'उत्पाद विवरण' },
      { name: 'price', type: 'number', description: 'USD में मूल्य', notNull: true },
      { name: 'category', type: 'text', description: 'उत्पाद श्रेणी' },
      { name: 'in_stock', type: 'boolean', description: 'इन्वेंट्री उपलब्धता', defaultValue: true },
      { name: 'supplier_email', type: 'email', description: 'आपूर्तिकर्ता संपर्क' },
      { name: 'website', type: 'url', description: 'उत्पाद वेबसाइट' },
      { name: 'created_at', type: 'date', description: 'निर्माण तिथि' }
    ];

    for (const column of columns) {
      await this.sdk.addColumn(this.tableId!, column);
    }
  }

  async addProduct(productData: any) {
    if (!this.tableId) throw new Error('तालिका आरंभ नहीं हुई');
    
    try {
      const result = await this.sdk.addRow(this.tableId, {
        ...productData,
        created_at: new Date().toISOString()
      });
      console.log('उत्पाद जोड़ा:', result);
      return result;
    } catch (error) {
      console.error('उत्पाद जोड़ने में विफल:', error);
      throw error;
    }
  }

  async searchProducts(searchTerm: string, category?: string, minPrice?: number, maxPrice?: number) {
    if (!this.tableId) throw new Error('तालिका आरंभ नहीं हुई');

    const filters = [];
    
    if (category) {
      filters.push({ column: 'category', operator: 'eq', value: category });
    }
    if (minPrice !== undefined) {
      filters.push({ column: 'price', operator: 'gte', value: minPrice });
    }
    if (maxPrice !== undefined) {
      filters.push({ column: 'price', operator: 'lte', value: maxPrice });
    }

    try {
      const results = await this.sdk.queryTable(this.tableId, {
        filters,
        pagination: { search: searchTerm, limit: 50 },
        sort: [{ column: 'name', direction: 'asc' }]
      });
      return results;
    } catch (error) {
      console.error('खोज विफल:', error);
      throw error;
    }
  }
}

const productManager = new ProductManager();
await productManager.initializeTable();
await productManager.addProduct({
  name: 'वायरलेस हेडफोन',
  price: 199.99,
  category: 'इलेक्ट्रॉनिक्स'
});

// अच्छा: फ़िल्टर और पेजिनेशन के साथ कुशल क्वेरी
const results = await smartTablesSDK.queryTable(tableId, {
  filters: [{ column: 'status', operator: 'eq', value: 'active' }],
  pagination: { limit: 50, page: 1 },
  sort: [{ column: 'created_at', direction: 'desc' }]
});

// बुरा: फ़िल्टर के बिना सभी डेटा प्राप्त करना
const allResults = await smartTablesSDK.queryTable(tableId);

// अच्छा: अच्छी तरह परिभाषित कॉलम स्कीमा
await smartTablesSDK.addColumn(tableId, {
  name: 'email',
  type: 'email',
  description: 'ग्राहक ईमेल पता',
  notNull: true,
  unique: true
});

// बुरा: अस्पष्ट कॉलम परिभाषा
await smartTablesSDK.addColumn(tableId, {
  name: 'data',
  type: 'text'
});

async function safeTableOperation(tableId: string, data: any) {
  try {
    if (!data.email || !data.email.includes('@')) {
      throw new Error('अमान्य ईमेल प्रारूप');
    }
    
    const result = await smartTablesSDK.addRow(tableId, data);
    return result;
  } catch (error) {
    console.error('संचालन विफल:', error);
    if (error.message.includes('unique constraint')) {
      throw new Error('ईमेल पहले से मौजूद है');
    }
    throw error;
  }
}