@kmlckj/licos-platform-sdk 0.5.0 → 0.6.1

package/src/index.d.ts

@@ -1,89 +1,206 @@
-export interface UploadResult {
-  bucket: string;
-  object_key: string;
-  file_name: string;
-  content_type: string;
-  size_bytes: number;
-  preview_url: string;
-  download_url: string;
+export class PlatformSdkError extends Error {
+  status?: number;
+  code?: number;
+  details?: unknown;
 }
 
-export interface BlobLike {
-  arrayBuffer(): Promise<ArrayBuffer>;
-  readonly size?: number;
-  readonly type?: string;
-  readonly name?: string;
+export class ConfigurationError extends PlatformSdkError {}
+export class ApiError extends PlatformSdkError {}
+
+export interface DatabaseFilter {
+  field: string;
+  op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'like' | 'ilike' | string;
+  value?: unknown;
 }
 
-export interface UploadBinaryDescriptor {
-  data?: ArrayBuffer | ArrayBufferView | BlobLike;
-  file?: ArrayBuffer | ArrayBufferView | BlobLike;
-  fileName?: string;
-  contentType?: string;
+export interface DatabaseOrderBy {
+  field: string;
+  direction?: 'asc' | 'desc';
+}
+
+export interface DatabaseRange {
+  from: number;
+  to: number;
+}
+
+export interface DatabaseResponse {
+  data?: Record<string, unknown>[];
+  count?: number;
+  affectedRows?: number;
+  message?: string;
+  [key: string]: unknown;
+}
+
+export interface DatabaseQueryOptions {
+  select?: string | string[];
+  filters?: DatabaseFilter[];
+  orderBy?: DatabaseOrderBy[];
+  range?: DatabaseRange;
+  limit?: number;
+  offset?: number;
+  count?: boolean;
+  head?: boolean;
+}
+
+export interface DatabaseMutationOptions {
+  row?: Record<string, unknown>;
+  rows?: Record<string, unknown>[];
+  values?: Record<string, unknown>;
+  filters?: DatabaseFilter[];
+  updates?: Array<{ filters?: DatabaseFilter[]; values?: Record<string, unknown> }>;
+  deletes?: Array<{ filters?: DatabaseFilter[] }>;
+  conflictKeys?: string[];
+  returning?: boolean;
+}
+
+export interface DatabaseOperation {
+  type: 'query' | 'insert' | 'update' | 'delete' | 'upsert' | string;
+  request: Record<string, unknown>;
 }
 
-export type UploadSource =
-  | string
-  | ArrayBuffer
-  | ArrayBufferView
-  | BlobLike
-  | UploadBinaryDescriptor;
-
-export interface StorageClientOptions {
-  baseUrl?: string;
-  token?: string;
-  userId?: string;
+export interface TableQuery {
+  select(...fields: string[]): TableQuery;
+  filter(field: string, op: string, value?: unknown): TableQuery;
+  eq(field: string, value: unknown): TableQuery;
+  neq(field: string, value: unknown): TableQuery;
+  gt(field: string, value: unknown): TableQuery;
+  gte(field: string, value: unknown): TableQuery;
+  lt(field: string, value: unknown): TableQuery;
+  lte(field: string, value: unknown): TableQuery;
+  in(field: string, value: unknown[]): TableQuery;
+  notIn(field: string, value: unknown[]): TableQuery;
+  isNull(field: string): TableQuery;
+  isNotNull(field: string): TableQuery;
+  like(field: string, value: string): TableQuery;
+  ilike(field: string, value: string): TableQuery;
+  order(field: string, options?: { desc?: boolean }): TableQuery;
+  range(from: number, to: number): TableQuery;
+  limit(value: number): TableQuery;
+  offset(value: number): TableQuery;
+  withCount(options?: { head?: boolean }): TableQuery;
+  execute(): Promise<DatabaseResponse>;
+  single(): Promise<DatabaseResponse>;
+  maybeSingle(): Promise<DatabaseResponse>;
+}
+
+export function query(table: string, options?: DatabaseQueryOptions): Promise<DatabaseResponse>;
+export function single(table: string, options?: DatabaseQueryOptions & { maybe?: boolean }): Promise<DatabaseResponse>;
+export function maybeSingle(table: string, options?: DatabaseQueryOptions): Promise<DatabaseResponse>;
+export function aggregate(table: string, aggregateName: string, options?: { field?: string; groupBy?: string[]; filters?: DatabaseFilter[] }): Promise<DatabaseResponse>;
+export function insert(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function updateRows(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function deleteRows(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function upsert(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function transaction(operations: DatabaseOperation[]): Promise<DatabaseResponse[]>;
+export function rpc(functionName: string, args?: Record<string, unknown>): Promise<DatabaseResponse>;
+export function table(name: string): TableQuery;
+
+export const database: {
+  query: typeof query;
+  single: typeof single;
+  maybeSingle: typeof maybeSingle;
+  aggregate: typeof aggregate;
+  insert: typeof insert;
+  updateRows: typeof updateRows;
+  deleteRows: typeof deleteRows;
+  upsert: typeof upsert;
+  transaction: typeof transaction;
+  rpc: typeof rpc;
+  table: typeof table;
+};
+
+export interface StorageSummary {
+  workspaceId?: string;
   projectId?: string;
-  fetch?: typeof fetch;
-  headers?: HeadersInit;
-  credentials?: RequestCredentials;
+  scope?: string;
+  bucketName?: string;
+  usedSizeBytes?: number;
+  fileCount?: number;
+  folderCount?: number;
+  serviceEnabled?: boolean;
+  [key: string]: unknown;
 }
 
-export interface UploadProjectOptions extends StorageClientOptions {
-  userId?: string;
+export interface StorageFolder {
+  id?: string;
+  workspaceId?: string;
   projectId?: string;
+  scope?: string;
+  parentId?: string | null;
+  folderName?: string;
+  folderPath?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  [key: string]: unknown;
 }
 
-export class PlatformSdkError extends Error {
-  status?: number;
-  code?: number;
-  details?: unknown;
+export interface StorageFile {
+  id?: string;
+  workspaceId?: string;
+  projectId?: string;
+  scope?: string;
+  folderId?: string | null;
+  folderPath?: string;
+  fileName?: string;
+  contentType?: string;
+  sizeBytes?: number;
+  storageBucket?: string;
+  storageKey?: string;
+  downloadUrl?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  [key: string]: unknown;
 }
 
-export class ConfigurationError extends PlatformSdkError {}
-export class ApiError extends PlatformSdkError {}
+export interface StorageEntries {
+  currentFolderId?: string | null;
+  currentFolderName?: string;
+  currentFolderPath?: string;
+  breadcrumbs?: unknown[];
+  folders?: StorageFolder[];
+  files?: StorageFile[];
+  [key: string]: unknown;
+}
 
-export class StorageClient {
-  constructor(options?: StorageClientOptions);
-  previewUrl(bucket: string, objectKey: string): string;
-  downloadUrl(bucket: string, objectKey: string): string;
-  uploadUser(file: UploadSource): Promise<UploadResult>;
-  uploadProject(file: UploadSource, options?: UploadProjectOptions): Promise<UploadResult>;
-  download(url: string): Promise<Blob>;
-  download(url: string, outputPath: string): Promise<string>;
+export interface UploadFileOptions {
+  folderId?: string;
+  fileName?: string;
+  contentType?: string;
+}
+
+export interface ShareUrlOptions {
+  expirySeconds?: number;
 }
 
-export function previewUrl(
-  bucket: string,
-  objectKey: string,
-  options?: StorageClientOptions,
-): string;
-export function downloadUrl(
-  bucket: string,
-  objectKey: string,
-  options?: StorageClientOptions,
-): string;
-export function uploadUser(
-  file: UploadSource,
-  options?: StorageClientOptions,
-): Promise<UploadResult>;
-export function uploadProject(
-  file: UploadSource,
-  options?: UploadProjectOptions,
-): Promise<UploadResult>;
-export function download(url: string, options?: StorageClientOptions): Promise<Blob>;
-export function download(
-  url: string,
-  outputPath: string,
-  options?: StorageClientOptions,
-): Promise<string>;
+export function summary(): Promise<StorageSummary>;
+export function listFolders(): Promise<StorageFolder[]>;
+export function listEntries(options?: { folderId?: string }): Promise<StorageEntries>;
+export function listFiles(): Promise<StorageFile[]>;
+export function createFolder(folderName: string, options?: { parentId?: string }): Promise<StorageFolder>;
+export function renameFolder(folderId: string, folderName: string): Promise<StorageFolder>;
+export function deleteFolder(folderId: string): Promise<void>;
+export function uploadFile(
+  input: string | Blob | Buffer | Uint8Array,
+  options?: UploadFileOptions,
+): Promise<StorageFile>;
+export function renameFile(fileId: string, fileName: string): Promise<StorageFile>;
+export function moveFile(fileId: string, options?: { folderId?: string }): Promise<StorageFile>;
+export function shareUrl(fileId: string, options?: ShareUrlOptions): Promise<{ url?: string; expiresAt?: string; [key: string]: unknown }>;
+export function objectExists(options?: { fileId?: string; objectKey?: string }): Promise<{ fileId?: string; bucketName?: string; objectKey?: string; exists?: boolean; [key: string]: unknown }>;
+export function deleteFile(fileId: string): Promise<void>;
+
+export const storage: {
+  summary: typeof summary;
+  listFolders: typeof listFolders;
+  listEntries: typeof listEntries;
+  listFiles: typeof listFiles;
+  createFolder: typeof createFolder;
+  renameFolder: typeof renameFolder;
+  deleteFolder: typeof deleteFolder;
+  uploadFile: typeof uploadFile;
+  renameFile: typeof renameFile;
+  moveFile: typeof moveFile;
+  shareUrl: typeof shareUrl;
+  objectExists: typeof objectExists;
+  deleteFile: typeof deleteFile;
+};

package/src/index.js

@@ -1,120 +1,3 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import {
-  ApiError,
-  ConfigurationError,
-  PlatformSdkError,
-  downloadBlob,
-  encodeObjectKey,
-  encodeStorageSegment,
-  fileNameFromPath,
-  guessContentType,
-  normalizeBaseUrl,
-  resolveProjectId,
-  resolveUserId,
-  uploadFile,
-} from './shared.js';
-
-export class StorageClient {
-  constructor(options = {}) {
-    this.baseUrl = options.baseUrl;
-    this.token = options.token;
-    this.userId = options.userId;
-    this.projectId = options.projectId;
-    this.fetchImpl = options.fetch ?? fetch;
-    this.headers = options.headers;
-    this.credentials = options.credentials;
-  }
-
-  previewUrl(bucket, objectKey) {
-    const baseUrl = normalizeBaseUrl(this.baseUrl);
-    return `${baseUrl}/api/v1/public/storage/${encodeStorageSegment(bucket)}/${encodeObjectKey(objectKey)}`;
-  }
-
-  downloadUrl(bucket, objectKey) {
-    return `${this.previewUrl(bucket, objectKey)}?download=1`;
-  }
-
-  async uploadUser(file) {
-    const baseUrl = normalizeBaseUrl(this.baseUrl);
-    return this.#upload(`${baseUrl}/api/v1/storage/upload/user`, file);
-  }
-
-  async uploadProject(file, options = {}) {
-    const baseUrl = normalizeBaseUrl(this.baseUrl);
-    const userId = resolveUserId(options.userId ?? this.userId);
-    const projectId = resolveProjectId(options.projectId ?? this.projectId);
-    return this.#upload(
-      `${baseUrl}/api/v1/storage/upload/project/${encodeStorageSegment(userId)}/${encodeStorageSegment(projectId)}`,
-      file,
-    );
-  }
-
-  async download(url, outputPath) {
-    const blob = await downloadBlob(this.fetchImpl, url, {
-      token: this.token,
-      headers: this.headers,
-      credentials: this.credentials,
-    });
-    if (outputPath === undefined) {
-      return blob;
-    }
-    const buffer = Buffer.from(await blob.arrayBuffer());
-    await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, buffer);
-    return outputPath;
-  }
-
-  async #upload(url, file) {
-    return uploadFile(
-      this.fetchImpl,
-      url,
-      file,
-      {
-        token: this.token,
-        headers: this.headers,
-        credentials: this.credentials,
-      },
-      async (filePath) => {
-        const fileBuffer = await fs.readFile(filePath);
-        const fileName = fileNameFromPath(filePath);
-        const contentType = guessContentType(fileName);
-        return {
-          fileName,
-          contentType,
-          blob: new Blob([fileBuffer], { type: contentType }),
-        };
-      },
-    );
-  }
-}
-
-function defaultClient(options = {}) {
-  return new StorageClient(options);
-}
-
-export function previewUrl(bucket, objectKey, options = {}) {
-  return defaultClient(options).previewUrl(bucket, objectKey);
-}
-
-export function downloadUrl(bucket, objectKey, options = {}) {
-  return defaultClient(options).downloadUrl(bucket, objectKey);
-}
-
-export async function uploadUser(filePath, options = {}) {
-  return defaultClient(options).uploadUser(filePath);
-}
-
-export async function uploadProject(filePath, options = {}) {
-  return defaultClient(options).uploadProject(filePath, options);
-}
-
-export async function download(url, outputPathOrOptions, maybeOptions = {}) {
-  if (typeof outputPathOrOptions === 'string') {
-    return defaultClient(maybeOptions).download(url, outputPathOrOptions);
-  }
-  return defaultClient(outputPathOrOptions ?? {}).download(url);
-}
-
-export { PlatformSdkError, ConfigurationError, ApiError };
+export { PlatformSdkError, ConfigurationError, ApiError } from './shared.js';
+export * from './database.js';
+export * from './storage.js';

package/src/runtime.js

@@ -0,0 +1,70 @@
+import { ConfigurationError } from './shared.js';
+
+export function env(name) {
+  const value = process.env[name];
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function normalizeBaseUrl(value) {
+  let trimmed = value.trim().replace(/\/+$/, '');
+  if (trimmed.endsWith('/api/v1')) {
+    trimmed = trimmed.slice(0, -'/api/v1'.length);
+  }
+  return trimmed.replace(/\/+$/, '');
+}
+
+function serviceBaseUrl(hostEnv, portEnv, defaultPort) {
+  const host = env(hostEnv);
+  if (!host) return undefined;
+  return `http://${host}:${env(portEnv) || defaultPort}`;
+}
+
+export function platformBaseUrl() {
+  const value =
+    env('LICOS_PLATFORM_API_BASE_URL') ||
+    serviceBaseUrl('AIOS_PLATFORM_SERVICE_HOST', 'AIOS_PLATFORM_SERVICE_PORT', '9100') ||
+    serviceBaseUrl('LICOS_PLATFORM_SERVICE_HOST', 'LICOS_PLATFORM_SERVICE_PORT', '9100') ||
+    serviceBaseUrl('PLATFORM_SERVICE_HOST', 'PLATFORM_SERVICE_PORT', '9100');
+  if (!value) {
+    throw new ConfigurationError('LICOS_PLATFORM_API_BASE_URL is not configured');
+  }
+  return normalizeBaseUrl(value);
+}
+
+export function projectEnvironment(overrideEnvName) {
+  const explicit = ((overrideEnvName ? env(overrideEnvName) : undefined) || '').toLowerCase();
+  if (explicit === 'dev' || explicit === 'prod') return explicit;
+  const projectEnv = (env('LICOS_PROJECT_ENV') || env('AGENT_ENV') || '').toLowerCase();
+  return ['prod', 'production', 'release'].includes(projectEnv) ? 'prod' : 'dev';
+}
+
+export function runtimeConfig({ environmentOverrideEnv } = {}) {
+  const projectId = env('LICOS_PROJECT_ID') || env('AGENT_PROJECT_ID');
+  if (!projectId) {
+    throw new ConfigurationError('LICOS_PROJECT_ID or AGENT_PROJECT_ID is not configured');
+  }
+  const token = env('LICOS_RUNTIME_TOKEN') || env('LICOS_USER_TOKEN');
+  if (!token) {
+    throw new ConfigurationError('LICOS_RUNTIME_TOKEN or LICOS_USER_TOKEN is not configured');
+  }
+  return {
+    baseUrl: platformBaseUrl(),
+    projectId,
+    environment: projectEnvironment(environmentOverrideEnv),
+    token,
+    workspaceId: env('LICOS_WORKSPACE_ID') || env('AGENT_WORKSPACE_ID'),
+    userId: env('LICOS_USER_ID') || env('AGENT_USER_ID'),
+  };
+}
+
+export function authHeaders(config, contentType = 'application/json') {
+  const result = {
+    Authorization: `Bearer ${config.token}`,
+  };
+  if (contentType) result['Content-Type'] = contentType;
+  if (config.workspaceId) result['X-Workspace-Id'] = config.workspaceId;
+  if (config.userId) result['X-User-Id'] = config.userId;
+  return result;
+}