@kmlckj/licos-platform-sdk 0.5.0 → 0.6.1

package/src/shared.js

@@ -10,249 +10,3 @@ export class PlatformSdkError extends Error {
 
 export class ConfigurationError extends PlatformSdkError {}
 export class ApiError extends PlatformSdkError {}
-
-export function isNodeRuntime() {
-  return typeof process !== 'undefined' && !!process?.versions?.node;
-}
-
-function readEnv(name) {
-  if (typeof process === 'undefined' || !process?.env) {
-    return undefined;
-  }
-  const value = process.env[name];
-  return value ? value : undefined;
-}
-
-export function requireEnv(name) {
-  const value = readEnv(name);
-  if (value) {
-    return value;
-  }
-  throw new ConfigurationError(`Missing required environment variable: ${name}`);
-}
-
-export function normalizeBaseUrl(baseUrl) {
-  if (typeof baseUrl === 'string') {
-    return baseUrl.replace(/\/+$/, '');
-  }
-
-  const envBaseUrl = readEnv('LICOS_ORCHESTRATOR_API_BASE_URL');
-  if (envBaseUrl) {
-    return envBaseUrl.replace(/\/+$/, '');
-  }
-
-  if (!isNodeRuntime()) {
-    return '';
-  }
-
-  throw new ConfigurationError(
-    'Missing required environment variable: LICOS_ORCHESTRATOR_API_BASE_URL',
-  );
-}
-
-export function resolveUserId(userId) {
-  return userId ?? requireEnv('LICOS_USER_ID');
-}
-
-export function resolveProjectId(projectId) {
-  return projectId ?? requireEnv('LICOS_PROJECT_ID');
-}
-
-export function encodeStorageSegment(value) {
-  return encodeURIComponent(value);
-}
-
-export function encodeObjectKey(value) {
-  return value.split('/').map(encodeStorageSegment).join('/');
-}
-
-export function fileNameFromPath(filePath) {
-  const parts = String(filePath).split(/[\\/]/);
-  const fileName = parts[parts.length - 1];
-  return fileName || 'upload.bin';
-}
-
-export function guessContentType(fileName) {
-  const ext = /\.[^./\\]+$/.exec(String(fileName).toLowerCase())?.[0] ?? '';
-  switch (ext) {
-    case '.txt':
-      return 'text/plain';
-    case '.json':
-      return 'application/json';
-    case '.pdf':
-      return 'application/pdf';
-    case '.png':
-      return 'image/png';
-    case '.jpg':
-    case '.jpeg':
-      return 'image/jpeg';
-    case '.gif':
-      return 'image/gif';
-    case '.webp':
-      return 'image/webp';
-    case '.svg':
-      return 'image/svg+xml';
-    case '.md':
-      return 'text/markdown';
-    default:
-      return 'application/octet-stream';
-  }
-}
-
-function isBlobLike(value) {
-  return !!value && typeof value === 'object' && typeof value.arrayBuffer === 'function';
-}
-
-function isBinaryDescriptor(value) {
-  if (!value || typeof value !== 'object' || isBlobLike(value)) {
-    return false;
-  }
-  return 'data' in value || 'file' in value;
-}
-
-function toUint8Array(data) {
-  if (data instanceof Uint8Array) {
-    return data;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  return new Uint8Array(data);
-}
-
-async function normalizeBinaryPayload(data, overrides = {}) {
-  if (isBlobLike(data)) {
-    const fileName =
-      overrides.fileName ??
-      (typeof data.name === 'string' && data.name ? data.name : undefined) ??
-      'upload.bin';
-    const contentType =
-      overrides.contentType ??
-      (typeof data.type === 'string' && data.type ? data.type : undefined) ??
-      guessContentType(fileName);
-    return {
-      fileName,
-      contentType,
-      blob: new Blob([await data.arrayBuffer()], { type: contentType }),
-    };
-  }
-
-  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-    const fileName = overrides.fileName ?? 'upload.bin';
-    const contentType = overrides.contentType ?? guessContentType(fileName);
-    return {
-      fileName,
-      contentType,
-      blob: new Blob([toUint8Array(data)], { type: contentType }),
-    };
-  }
-
-  throw new ConfigurationError(
-    'Unsupported upload input. Use a file path string, Blob/File, ArrayBuffer, TypedArray, or { data, fileName }.',
-  );
-}
-
-export async function normalizeUploadSource(source, readPathSource) {
-  if (typeof source === 'string') {
-    if (!readPathSource) {
-      throw new ConfigurationError(
-        'Front-end mode does not support filesystem path uploads. Pass File, Blob, ArrayBuffer, TypedArray, or { data, fileName } instead.',
-      );
-    }
-    return readPathSource(source);
-  }
-
-  if (isBinaryDescriptor(source)) {
-    return normalizeBinaryPayload(source.data ?? source.file, {
-      fileName: source.fileName,
-      contentType: source.contentType,
-    });
-  }
-
-  return normalizeBinaryPayload(source);
-}
-
-function headersFromInit(headersInit) {
-  return new Headers(headersInit ?? undefined);
-}
-
-export function buildRequestHeaders(options = {}, { authenticated = false } = {}) {
-  const headers = headersFromInit(options.headers);
-  if (authenticated && !headers.has('Authorization')) {
-    const resolvedToken = options.token ?? readEnv('LICOS_USER_TOKEN');
-    if (resolvedToken) {
-      headers.set('Authorization', `Bearer ${resolvedToken}`);
-    } else if (isNodeRuntime()) {
-      throw new ConfigurationError(
-        'Missing authentication token. Pass options.token, provide an Authorization header, or set LICOS_USER_TOKEN.',
-      );
-    }
-  }
-  return headers;
-}
-
-export function buildRequestInit(options = {}, init = {}) {
-  const requestInit = { ...init };
-  if (options.credentials) {
-    requestInit.credentials = options.credentials;
-  }
-  return requestInit;
-}
-
-export async function readJsonEnvelope(response) {
-  let payload;
-  try {
-    payload = await response.json();
-  } catch (error) {
-    throw new ApiError('Platform API returned non-JSON response', {
-      status: response.status,
-      details: error instanceof Error ? error.message : String(error),
-    });
-  }
-
-  if (!response.ok || payload?.code !== 0) {
-    throw new ApiError(payload?.message ?? `Platform API failed: HTTP ${response.status}`, {
-      status: response.status,
-      code: payload?.code,
-      details: payload?.data ?? payload,
-    });
-  }
-  return payload.data;
-}
-
-export async function downloadBlob(fetchImpl, url, options = {}) {
-  const response = await fetchImpl(
-    url,
-    buildRequestInit(options, {
-      method: 'GET',
-      headers: buildRequestHeaders(options, { authenticated: true }),
-    }),
-  );
-  if (!response.ok) {
-    throw new ApiError(`Platform download failed: HTTP ${response.status}`, {
-      status: response.status,
-    });
-  }
-  if (typeof response.blob === 'function') {
-    return response.blob();
-  }
-  return new Blob([await response.arrayBuffer()], {
-    type: response.headers.get('content-type') ?? undefined,
-  });
-}
-
-export async function uploadFile(fetchImpl, url, source, options = {}, readPathSource) {
-  const normalized = await normalizeUploadSource(source, readPathSource);
-  const formData = new FormData();
-  formData.append('file', normalized.blob, normalized.fileName);
-
-  const response = await fetchImpl(
-    url,
-    buildRequestInit(options, {
-      method: 'POST',
-      headers: buildRequestHeaders(options, { authenticated: true }),
-      body: formData,
-    }),
-  );
-  return readJsonEnvelope(response);
-}

package/src/storage.js

@@ -0,0 +1,155 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { ApiError } from './shared.js';
+import { authHeaders, runtimeConfig } from './runtime.js';
+
+function storageConfig() {
+  return runtimeConfig({ environmentOverrideEnv: 'LICOS_STORAGE_SCOPE' });
+}
+
+function query(config, params = {}) {
+  const search = new URLSearchParams();
+  search.set('projectId', config.projectId);
+  search.set('scope', config.environment);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null) search.set(key, String(value));
+  }
+  return search.toString();
+}
+
+function storageUrl(config, route, params) {
+  return `${config.baseUrl}/api/v1/studio/storage${route}?${query(config, params)}`;
+}
+
+async function decodeResponse(response) {
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    throw new ApiError(text || `platform storage API returned ${response.status}`, {
+      status: response.status,
+      details: payload,
+    });
+  }
+  if (!payload || typeof payload !== 'object') return payload;
+  if ((payload.code !== undefined && payload.code !== 0) || payload.success === false) {
+    throw new ApiError(payload.message || 'platform storage API failed', {
+      status: response.status,
+      code: typeof payload.code === 'number' ? payload.code : undefined,
+      details: payload,
+    });
+  }
+  return payload.data;
+}
+
+async function requestJson(method, route, { params, body } = {}) {
+  const config = storageConfig();
+  const response = await fetch(storageUrl(config, route, params), {
+    method,
+    headers: authHeaders(config),
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  return decodeResponse(response);
+}
+
+async function filePart(input, options = {}) {
+  if (typeof input === 'string') {
+    const data = await readFile(input);
+    return {
+      blob: new Blob([data], { type: options.contentType || 'application/octet-stream' }),
+      fileName: options.fileName || path.basename(input),
+    };
+  }
+  if (input instanceof Blob) {
+    return { blob: input, fileName: options.fileName || 'file' };
+  }
+  if (input instanceof Uint8Array || Buffer.isBuffer(input)) {
+    return {
+      blob: new Blob([input], { type: options.contentType || 'application/octet-stream' }),
+      fileName: options.fileName || 'file',
+    };
+  }
+  throw new TypeError('uploadFile input must be a file path, Blob, Buffer, or Uint8Array');
+}
+
+export async function summary() {
+  return requestJson('GET', '/summary');
+}
+
+export async function listFolders() {
+  return (await requestJson('GET', '/folders')) || [];
+}
+
+export async function listEntries({ folderId } = {}) {
+  return requestJson('GET', '/entries', { params: { folderId } });
+}
+
+export async function listFiles() {
+  return (await requestJson('GET', '/files')) || [];
+}
+
+export async function createFolder(folderName, { parentId } = {}) {
+  return requestJson('POST', '/folders', { body: { folderName, parentId } });
+}
+
+export async function renameFolder(folderId, folderName) {
+  return requestJson('PUT', `/folders/${encodeURIComponent(folderId)}`, { body: { folderName } });
+}
+
+export async function deleteFolder(folderId) {
+  await requestJson('DELETE', `/folders/${encodeURIComponent(folderId)}`);
+}
+
+export async function uploadFile(input, options = {}) {
+  const config = storageConfig();
+  const { blob, fileName } = await filePart(input, options);
+  const form = new FormData();
+  form.set('projectId', config.projectId);
+  form.set('scope', config.environment);
+  if (options.folderId) form.set('folderId', options.folderId);
+  form.set('file', blob, fileName);
+  const response = await fetch(`${config.baseUrl}/api/v1/studio/storage/files/upload`, {
+    method: 'POST',
+    headers: authHeaders(config, undefined),
+    body: form,
+  });
+  return decodeResponse(response);
+}
+
+export async function renameFile(fileId, fileName) {
+  return requestJson('PUT', `/files/${encodeURIComponent(fileId)}/rename`, { body: { fileName } });
+}
+
+export async function moveFile(fileId, { folderId } = {}) {
+  return requestJson('PUT', `/files/${encodeURIComponent(fileId)}/move`, { body: { folderId } });
+}
+
+export async function shareUrl(fileId, { expirySeconds } = {}) {
+  return requestJson('POST', `/files/${encodeURIComponent(fileId)}/share-url`, {
+    body: { expirySeconds },
+  });
+}
+
+export async function objectExists({ fileId, objectKey } = {}) {
+  return requestJson('POST', '/objects/exists', { body: { fileId, objectKey } });
+}
+
+export async function deleteFile(fileId) {
+  await requestJson('DELETE', `/files/${encodeURIComponent(fileId)}`);
+}
+
+export const storage = {
+  summary,
+  listFolders,
+  listEntries,
+  listFiles,
+  createFolder,
+  renameFolder,
+  deleteFolder,
+  uploadFile,
+  renameFile,
+  moveFile,
+  shareUrl,
+  objectExists,
+  deleteFile,
+};