@msssystems/mss-link-sdk 0.1.7 → 0.1.9

package/dist/client/drive-file-runtime.contracts.d.ts

@@ -0,0 +1,39 @@
+import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
+import type { MediaMessageAttachmentMetadata } from './media-message.contracts';
+export type DriveFilePreviewKind = 'image' | 'pdf' | 'text' | 'unsupported' | 'video';
+export interface DriveFileContentEnvelope {
+    algorithm?: 'AES-256-GCM' | string | null;
+    keyId?: string | null;
+    nonce?: string | null;
+    wrappedKey?: string | null;
+}
+export interface DriveFileRuntimeMetadataInput {
+    fileName: string;
+    mimeType: string;
+    size: number | string;
+    storageKey: string;
+    encryption: DriveFileContentEnvelope;
+}
+export interface DriveFileAttachmentInput {
+    decrypted: DecryptedMediaBlobResult;
+    fallbackFileName?: string;
+    fallbackMimeType?: string;
+}
+export interface DriveFilePreviewInput {
+    decrypted: DecryptedMediaBlobResult;
+    fallbackFileName?: string;
+    fallbackMimeType?: string;
+}
+export interface PreparedDriveFileAttachment {
+    file: File;
+    fileName: string;
+    mimeType: string;
+}
+export interface PreparedDriveFilePreview {
+    blob: Blob;
+    fileName: string;
+    kind: DriveFilePreviewKind;
+    mimeType: string;
+    text?: string;
+}
+export type DriveFileMediaMetadata = MediaMessageAttachmentMetadata;

package/dist/client/drive-file-runtime.contracts.js

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

package/dist/client/drive-file-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { DecryptedMediaBlobResult } from './media-crypto.contracts';
+import type { DriveFileAttachmentInput, DriveFileMediaMetadata, DriveFilePreviewInput, DriveFilePreviewKind, DriveFileRuntimeMetadataInput, PreparedDriveFileAttachment, PreparedDriveFilePreview } from './drive-file-runtime.contracts';
+export declare function buildDriveFileMediaMetadata(input: DriveFileRuntimeMetadataInput): DriveFileMediaMetadata;
+export declare function getDriveFilePreviewKind(mimeType: string): DriveFilePreviewKind;
+export declare function prepareDriveFileAttachment({ decrypted, fallbackFileName, fallbackMimeType, }: DriveFileAttachmentInput): PreparedDriveFileAttachment;
+export declare function prepareDriveFilePreview({ decrypted, fallbackFileName, fallbackMimeType, }: DriveFilePreviewInput): Promise<PreparedDriveFilePreview>;
+export declare function getDecryptedFileName(decrypted: DecryptedMediaBlobResult, fallbackFileName?: string): string;
+export declare function getDecryptedMimeType(decrypted: DecryptedMediaBlobResult, fallbackMimeType?: string): string;

package/dist/client/drive-file-runtime.js

@@ -0,0 +1,94 @@
+const DEFAULT_FILE_NAME = 'attachment';
+const DEFAULT_MIME_TYPE = 'application/octet-stream';
+export function buildDriveFileMediaMetadata(input) {
+    const fileName = normalizeOptionalText(input.fileName) ?? DEFAULT_FILE_NAME;
+    const mimeType = normalizeOptionalText(input.mimeType) ?? DEFAULT_MIME_TYPE;
+    const nonce = normalizeRequiredText(input.encryption.nonce, 'Drive file encryption nonce is required.');
+    const wrappedKey = normalizeRequiredText(input.encryption.wrappedKey, 'Drive file wrapped content key is required.');
+    return {
+        assetId: normalizeRequiredText(input.storageKey, 'Drive file storage key is required.'),
+        mimeType,
+        originalName: fileName,
+        size: String(input.size),
+        encryption: {
+            schema: 'mss.link.media-encryption.v1',
+            algorithm: normalizeDriveFileContentAlgorithm(input.encryption.algorithm),
+            ...(input.encryption.keyId ? { keyId: input.encryption.keyId } : {}),
+            nonce,
+            wrappedKey,
+        },
+    };
+}
+export function getDriveFilePreviewKind(mimeType) {
+    const normalizedMimeType = normalizeOptionalText(mimeType) ?? DEFAULT_MIME_TYPE;
+    if (normalizedMimeType.startsWith('image/')) {
+        return 'image';
+    }
+    if (normalizedMimeType.startsWith('video/')) {
+        return 'video';
+    }
+    if (normalizedMimeType === 'application/pdf') {
+        return 'pdf';
+    }
+    if (normalizedMimeType.startsWith('text/') ||
+        normalizedMimeType.includes('json')) {
+        return 'text';
+    }
+    return 'unsupported';
+}
+export function prepareDriveFileAttachment({ decrypted, fallbackFileName, fallbackMimeType, }) {
+    const fileName = getDecryptedFileName(decrypted, fallbackFileName);
+    const mimeType = getDecryptedMimeType(decrypted, fallbackMimeType);
+    return {
+        file: new File([decrypted.blob], fileName, { type: mimeType }),
+        fileName,
+        mimeType,
+    };
+}
+export async function prepareDriveFilePreview({ decrypted, fallbackFileName, fallbackMimeType, }) {
+    const fileName = getDecryptedFileName(decrypted, fallbackFileName);
+    const mimeType = getDecryptedMimeType(decrypted, fallbackMimeType);
+    const kind = getDriveFilePreviewKind(mimeType);
+    if (kind === 'text') {
+        return {
+            blob: decrypted.blob,
+            fileName,
+            kind,
+            mimeType,
+            text: await decrypted.blob.text(),
+        };
+    }
+    return {
+        blob: decrypted.blob,
+        fileName,
+        kind,
+        mimeType,
+    };
+}
+export function getDecryptedFileName(decrypted, fallbackFileName) {
+    return (normalizeOptionalText(decrypted.fileName) ??
+        normalizeOptionalText(fallbackFileName) ??
+        DEFAULT_FILE_NAME);
+}
+export function getDecryptedMimeType(decrypted, fallbackMimeType) {
+    return (normalizeOptionalText(decrypted.mimeType) ??
+        normalizeOptionalText(fallbackMimeType) ??
+        DEFAULT_MIME_TYPE);
+}
+function normalizeDriveFileContentAlgorithm(algorithm) {
+    if (!algorithm || algorithm === 'AES-256-GCM') {
+        return 'AES-256-GCM';
+    }
+    throw new Error(`Unsupported Drive file encryption algorithm: ${algorithm}`);
+}
+function normalizeRequiredText(value, message) {
+    const normalized = normalizeOptionalText(value);
+    if (!normalized) {
+        throw new Error(message);
+    }
+    return normalized;
+}
+function normalizeOptionalText(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}

package/dist/client/drive-sharing.contracts.d.ts

@@ -0,0 +1,64 @@
+export type DrivePermissionRole = 'editor' | 'owner' | 'viewer';
+export type DriveEditablePermissionRole = Exclude<DrivePermissionRole, 'owner'>;
+export type DriveVisibility = 'private' | 'shared';
+export type DriveItemType = 'file' | 'folder';
+export type DriveShareTargetType = 'user';
+export interface DriveShareTarget {
+    type: DriveShareTargetType;
+    userId?: string;
+    username?: string;
+}
+export interface DriveWrappedItemKey {
+    encryptedItemKey: string;
+    keyAlgorithm?: string;
+    keyNonce?: string;
+    keyRecipientId?: string;
+}
+export interface CreateDriveShareGrantInput {
+    role: DriveEditablePermissionRole;
+    target: DriveShareTarget;
+    wrappedItemKey: DriveWrappedItemKey;
+}
+export interface DriveShareGrantPayload {
+    encryptedItemKey: string;
+    keyAlgorithm?: string;
+    keyNonce?: string;
+    keyRecipientId?: string;
+    role: 'EDITOR' | 'VIEWER';
+    target: {
+        type: 'user';
+        userId?: string;
+        username?: string;
+    };
+}
+export interface DriveAccessPrincipal {
+    accountId: string;
+    avatarUrl: string | null;
+    displayName: string | null;
+    userId: string | null;
+    username: string | null;
+}
+export interface DriveAccessGrant {
+    createdAt: string;
+    encryptedItemKey: string;
+    fileId: string | null;
+    folderId: string | null;
+    grantee: DriveAccessPrincipal;
+    granteeAccountId: string;
+    id: string;
+    itemType: 'FILE' | 'FOLDER';
+    keyAlgorithm: string;
+    keyNonce: string | null;
+    keyRecipientId: string | null;
+    ownerAccountId: string;
+    role: 'EDITOR' | 'OWNER' | 'VIEWER';
+    updatedAt: string;
+}
+export interface DriveAccessResponse {
+    currentUserRole: 'EDITOR' | 'OWNER' | 'VIEWER';
+    grants: DriveAccessGrant[];
+    itemId: string;
+    itemType: 'FILE' | 'FOLDER';
+    owner: DriveAccessPrincipal;
+    visibility: 'PRIVATE' | 'SHARED';
+}

package/dist/client/drive-sharing.contracts.js

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

package/dist/client/drive-sharing.d.ts

@@ -0,0 +1,5 @@
+import type { CreateDriveShareGrantInput, DriveEditablePermissionRole, DriveShareGrantPayload, DriveShareTarget, DriveWrappedItemKey } from './drive-sharing.contracts';
+export declare function createDriveShareGrantPayload(input: CreateDriveShareGrantInput): DriveShareGrantPayload;
+export declare function normalizeDriveShareTarget(target: DriveShareTarget): DriveShareGrantPayload['target'];
+export declare function normalizeWrappedItemKey(key: DriveWrappedItemKey): Omit<DriveShareGrantPayload, 'role' | 'target'>;
+export declare function toApiDrivePermissionRole(role: DriveEditablePermissionRole): DriveShareGrantPayload['role'];

package/dist/client/drive-sharing.js

@@ -0,0 +1,51 @@
+const DEFAULT_KEY_ALGORITHM = 'X25519-AES-256-GCM';
+export function createDriveShareGrantPayload(input) {
+    return {
+        ...normalizeWrappedItemKey(input.wrappedItemKey),
+        role: toApiDrivePermissionRole(input.role),
+        target: normalizeDriveShareTarget(input.target),
+    };
+}
+export function normalizeDriveShareTarget(target) {
+    if (target.type !== 'user') {
+        throw new Error('Drive sharing supports only selected users in v1.');
+    }
+    const userId = target.userId?.trim();
+    const username = target.username?.trim().replace(/^@/, '').toLowerCase();
+    if (!userId && !username) {
+        throw new Error('Drive share target must include userId or username.');
+    }
+    return {
+        type: 'user',
+        ...(userId ? { userId } : {}),
+        ...(username ? { username } : {}),
+    };
+}
+export function normalizeWrappedItemKey(key) {
+    const encryptedItemKey = key.encryptedItemKey.trim();
+    const keyAlgorithm = (key.keyAlgorithm?.trim() || DEFAULT_KEY_ALGORITHM).trim();
+    const keyNonce = key.keyNonce?.trim();
+    const keyRecipientId = key.keyRecipientId?.trim();
+    if (!encryptedItemKey) {
+        throw new Error('Drive share requires encrypted wrapped item key.');
+    }
+    if (!keyAlgorithm) {
+        throw new Error('Drive share key algorithm is required.');
+    }
+    return {
+        encryptedItemKey,
+        keyAlgorithm,
+        ...(keyNonce ? { keyNonce } : {}),
+        ...(keyRecipientId ? { keyRecipientId } : {}),
+    };
+}
+export function toApiDrivePermissionRole(role) {
+    switch (role) {
+        case 'editor':
+            return 'EDITOR';
+        case 'viewer':
+            return 'VIEWER';
+        default:
+            throw new Error('Drive owner role cannot be granted through sharing.');
+    }
+}

package/dist/client/index.d.ts

@@ -1,6 +1,10 @@
 export * from './api-base-url';
 export * from './client-options';
 export * from './decryption-errors';
+export * from './drive-file-runtime';
+export * from './drive-file-runtime.contracts';
+export * from './drive-sharing';
+export * from './drive-sharing.contracts';
 export * from './local-crypto-health';
 export * from './local-crypto-health.contracts';
 export * from './media-crypto.contracts';

package/dist/client/index.js

@@ -1,6 +1,10 @@
 export * from './api-base-url';
 export * from './client-options';
 export * from './decryption-errors';
+export * from './drive-file-runtime';
+export * from './drive-file-runtime.contracts';
+export * from './drive-sharing';
+export * from './drive-sharing.contracts';
 export * from './local-crypto-health';
 export * from './local-crypto-health.contracts';
 export * from './media-crypto.contracts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msssystems/mss-link-sdk",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Official managed application SDK for MSS ecosystem",
   "type": "module",
   "main": "./dist/index.js",