@push.rocks/smartdb 4.0.2 → 4.2.0

package/ts/ts_smartdb/offline-inspection.ts

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import type {
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
   ILocalSmartDbOfflineStringValueInspection,
   ISmartDbManagementOperationOptions,
 } from './service-types.js';
@@ -20,6 +21,24 @@ export const localSmartDbOfflineInspectionBounds = {
   },
 } as const;
 
+export const localSmartDbOfflinePhysicalNamespaceInspectionBounds = {
+  maximumFolderPathBytes: 4096,
+  maximumRequestBytes: 2 * 1024 * 1024,
+  limits: {
+    maximumEntries: { minimum: 1, maximum: 100_000 },
+    maximumDatabases: { minimum: 1, maximum: 4096 },
+    maximumCollections: { minimum: 1, maximum: 10_000 },
+    maximumIndexes: { minimum: 1, maximum: 100_000 },
+    maximumDataFileBytes: { minimum: 64, maximum: 256 * 1024 * 1024 },
+    maximumWalFileBytes: { minimum: 64, maximum: 64 * 1024 * 1024 },
+    maximumIndexFileBytes: { minimum: 2, maximum: 16 * 1024 * 1024 },
+    maximumTotalFileBytes: { minimum: 1, maximum: 1024 * 1024 * 1024 * 1024 },
+    maximumRecordsPerCollection: { minimum: 1, maximum: 1_000_000 },
+    maximumRecordBytes: { minimum: 22, maximum: 17 * 1024 * 1024 },
+    maximumResultBytes: { minimum: 32, maximum: 16 * 1024 * 1024 },
+  },
+} as const;
+
 const inputKeys = new Set([
   'folderPath',
   'databaseName',
@@ -46,9 +65,57 @@ const requestEnvelopeBytes = plugins.buffer.Buffer.byteLength(
   'utf8',
 );
 
+const physicalNamespaceInputKeys = new Set(['folderPath', 'limits']);
+const physicalNamespaceLimitKeys = [
+  'maximumEntries',
+  'maximumDatabases',
+  'maximumCollections',
+  'maximumIndexes',
+  'maximumDataFileBytes',
+  'maximumWalFileBytes',
+  'maximumIndexFileBytes',
+  'maximumTotalFileBytes',
+  'maximumRecordsPerCollection',
+  'maximumRecordBytes',
+  'maximumResultBytes',
+] as const;
+const physicalNamespaceLimitKeySet = new Set<string>(physicalNamespaceLimitKeys);
+
 const isRecord = (valueArg: unknown): valueArg is Record<string, unknown> =>
   typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
 
+const requirePhysicalNamespacePlainObject = (
+  valueArg: unknown,
+  allowedKeysArg: Set<string>,
+  labelArg: string,
+): Record<string, unknown> => {
+  if (!isRecord(valueArg)) {
+    throw new TypeError(
+      `LocalSmartDb offline physical namespace inspection ${labelArg} must be a plain object`,
+    );
+  }
+  for (const key in valueArg) {
+    if (!allowedKeysArg.has(key)) {
+      throw new TypeError(
+        `LocalSmartDb offline physical namespace inspection ${labelArg} contains unknown key '${key}'`,
+      );
+    }
+  }
+  if (Object.getPrototypeOf(valueArg) !== Object.prototype) {
+    throw new TypeError(
+      `LocalSmartDb offline physical namespace inspection ${labelArg} must be a plain object`,
+    );
+  }
+  for (const key of allowedKeysArg) {
+    if (!Object.prototype.propertyIsEnumerable.call(valueArg, key)) {
+      throw new TypeError(
+        `LocalSmartDb offline physical namespace inspection ${labelArg} must contain own enumerable key '${key}'`,
+      );
+    }
+  }
+  return valueArg;
+};
+
 const rejectUnknownEnumerableKeys = (
   valueArg: object,
   allowedKeysArg: Set<string>,
@@ -219,6 +286,81 @@ export const normalizeLocalSmartDbOfflineInspectionInput = (
   return normalized;
 };
 
+export const normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput = (
+  inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection,
+): ILocalSmartDbOfflinePhysicalNamespaceInspection => {
+  const inputRecord = requirePhysicalNamespacePlainObject(
+    inputArg,
+    physicalNamespaceInputKeys,
+    'input',
+  );
+  const limits = requirePhysicalNamespacePlainObject(
+    inputRecord.limits,
+    physicalNamespaceLimitKeySet,
+    'limits',
+  );
+  const normalized: ILocalSmartDbOfflinePhysicalNamespaceInspection = {
+    folderPath: inputRecord.folderPath as string,
+    limits: {
+      maximumEntries: limits.maximumEntries as number,
+      maximumDatabases: limits.maximumDatabases as number,
+      maximumCollections: limits.maximumCollections as number,
+      maximumIndexes: limits.maximumIndexes as number,
+      maximumDataFileBytes: limits.maximumDataFileBytes as number,
+      maximumWalFileBytes: limits.maximumWalFileBytes as number,
+      maximumIndexFileBytes: limits.maximumIndexFileBytes as number,
+      maximumTotalFileBytes: limits.maximumTotalFileBytes as number,
+      maximumRecordsPerCollection: limits.maximumRecordsPerCollection as number,
+      maximumRecordBytes: limits.maximumRecordBytes as number,
+      maximumResultBytes: limits.maximumResultBytes as number,
+    },
+  };
+  const bounds = localSmartDbOfflinePhysicalNamespaceInspectionBounds;
+  if (typeof normalized.folderPath !== 'string') {
+    throw new TypeError(
+      'LocalSmartDb offline physical namespace inspection folderPath must be a string',
+    );
+  }
+  const folderPathBytes = plugins.buffer.Buffer.byteLength(normalized.folderPath, 'utf8');
+  if (folderPathBytes < 1 || folderPathBytes > bounds.maximumFolderPathBytes) {
+    throw new RangeError(
+      `LocalSmartDb offline physical namespace inspection folderPath must be between 1 and ${bounds.maximumFolderPathBytes} UTF-8 bytes`,
+    );
+  }
+  for (const character of normalized.folderPath) {
+    if (/\p{Cc}/u.test(character)) {
+      throw new TypeError(
+        'LocalSmartDb offline physical namespace inspection folderPath must not contain control characters',
+      );
+    }
+  }
+
+  for (const key of physicalNamespaceLimitKeys) {
+    const value = normalized.limits[key];
+    const range = bounds.limits[key];
+    if (!Number.isSafeInteger(value) || value < range.minimum || value > range.maximum) {
+      throw new RangeError(
+        `LocalSmartDb offline physical namespace inspection limits.${key} must be a safe integer between ${range.minimum} and ${range.maximum}`,
+      );
+    }
+  }
+
+  const requestBytes = plugins.buffer.Buffer.byteLength(JSON.stringify({
+    id: 'req_9007199254740991',
+    method: 'inspectOfflinePhysicalNamespaces',
+    params: {
+      folderPath: normalized.folderPath,
+      ...normalized.limits,
+    },
+  }), 'utf8');
+  if (requestBytes > bounds.maximumRequestBytes) {
+    throw new RangeError(
+      `LocalSmartDb offline physical namespace inspection request exceeds the ${bounds.maximumRequestBytes}-byte serialized limit`,
+    );
+  }
+  return normalized;
+};
+
 export const validateSmartDbManagementOperationOptions = (
   optionsArg?: ISmartDbManagementOperationOptions,
 ): void => {

package/ts/ts_smartdb/rust-db-bridge.ts

@@ -7,12 +7,15 @@ import {
   normalizeSmartDbResourceFenceError,
 } from './service-types.js';
 import {
+  normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput,
   normalizeLocalSmartDbOfflineInspectionInput,
   validateSmartDbManagementOperationOptions,
 } from './offline-inspection.js';
 import type {
   ISmartDbHealth,
   ISmartDbDatabaseTenantInput,
+  ISmartDbAttestDatabaseTenantInput,
+  ISmartDbAttestDatabaseTenantResult,
   ISmartDbEnsureDatabaseTenantInput,
   ISmartDbEnsureDatabaseTenantResult,
   ISmartDbAllocateDatabaseTenantInput,
@@ -34,6 +37,8 @@ import type {
   ISmartDbCommitDatabasePublicationInput,
   ISmartDbManagementOperationOptions,
   ISmartDbDatabaseResourceFenceState,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
   TSmartDbCommitDatabasePublicationResult,
@@ -42,6 +47,8 @@ import type {
 export type {
   ISmartDbHealth,
   ISmartDbDatabaseTenantInput,
+  ISmartDbAttestDatabaseTenantInput,
+  ISmartDbAttestDatabaseTenantResult,
   ISmartDbEnsureDatabaseTenantInput,
   ISmartDbEnsureDatabaseTenantResult,
   ISmartDbAllocateDatabaseTenantInput,
@@ -64,6 +71,9 @@ export type {
   ISmartDbManagementOperationOptions,
   ISmartDbDatabaseResourceFenceState,
   ILocalSmartDbOfflineInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
   TSmartDbCommitDatabasePublicationResult,
@@ -165,7 +175,15 @@ export interface ISmartDbMetrics {
 /**
  * Type-safe command definitions for the RustDb IPC protocol.
  */
+type TOfflinePhysicalNamespaceInspectionCommandParams = {
+  folderPath: string;
+} & ILocalSmartDbOfflinePhysicalNamespaceInspection['limits'];
+
 type TSmartDbCommands = {
+  inspectOfflinePhysicalNamespaces: {
+    params: TOfflinePhysicalNamespaceInspectionCommandParams;
+    result: ILocalSmartDbOfflinePhysicalNamespaceInspectionResult;
+  };
   inspectOfflineStringValue: {
     params: ILocalSmartDbOfflineStringValueInspection;
     result: TLocalSmartDbOfflineStringValueInspectionResult;
@@ -191,6 +209,10 @@ type TSmartDbCommands = {
     params: ISmartDbEnsureDatabaseTenantInput;
     result: ISmartDbEnsureDatabaseTenantResult;
   };
+  attestDatabaseTenant: {
+    params: ISmartDbAttestDatabaseTenantInput;
+    result: ISmartDbAttestDatabaseTenantResult;
+  };
   deleteDatabaseTenant: {
     params: ISmartDbDeleteDatabaseTenantInput;
     result: ISmartDbDeleteDatabaseTenantResult;
@@ -535,6 +557,28 @@ export class RustDbBridge extends EventEmitter {
 
   // --- Convenience methods for each management command ---
 
+  public async inspectOfflinePhysicalNamespaces(
+    inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection,
+    optionsArg?: ISmartDbManagementOperationOptions,
+  ): Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult> {
+    const input = normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput(inputArg);
+    validateSmartDbManagementOperationOptions(optionsArg);
+    const params: TOfflinePhysicalNamespaceInspectionCommandParams = {
+      folderPath: input.folderPath,
+      ...input.limits,
+    };
+    try {
+      return await this.bridge.sendCommand(
+        'inspectOfflinePhysicalNamespaces',
+        params,
+        optionsArg,
+      ) as ILocalSmartDbOfflinePhysicalNamespaceInspectionResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw error;
+    }
+  }
+
   public async inspectOfflineStringValue(
     inputArg: ILocalSmartDbOfflineStringValueInspection,
     optionsArg?: ISmartDbManagementOperationOptions,
@@ -647,6 +691,22 @@ export class RustDbBridge extends EventEmitter {
     }
   }
 
+  public async attestDatabaseTenant(
+    params: ISmartDbAttestDatabaseTenantInput,
+    optionsArg?: ISmartDbManagementOperationOptions,
+  ): Promise<ISmartDbAttestDatabaseTenantResult> {
+    try {
+      return await this.bridge.sendCommand(
+        'attestDatabaseTenant',
+        params,
+        optionsArg,
+      ) as ISmartDbAttestDatabaseTenantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeSmartDbResourceFenceError(error);
+    }
+  }
+
   public async allocateDatabaseTenant(
     params: ISmartDbAllocateDatabaseTenantInput,
     optionsArg?: ISmartDbManagementOperationOptions,

package/ts/ts_smartdb/server/SmartdbServer.ts

@@ -20,6 +20,8 @@ import type {
 import type {
   ISmartDbHealth,
   ISmartDbDatabaseTenantInput,
+  ISmartDbAttestDatabaseTenantInput,
+  ISmartDbAttestDatabaseTenantResult,
   ISmartDbEnsureDatabaseTenantInput,
   ISmartDbEnsureDatabaseTenantResult,
   ISmartDbAllocateDatabaseTenantInput,
@@ -455,6 +457,16 @@ export class SmartdbServer {
     return this.withTenantMongoUri(descriptor, params.password);
   }
 
+  /** Verify an exact tenant credential without changing provider state. */
+  async attestDatabaseTenant(
+    params: ISmartDbAttestDatabaseTenantInput,
+    optionsArg?: ISmartDbManagementOperationOptions,
+  ): Promise<ISmartDbAttestDatabaseTenantResult> {
+    return this.runDatabaseManagementOperation(
+      () => this.bridge.attestDatabaseTenant(params, optionsArg),
+    );
+  }
+
   /**
    * Delete a tenant database and its tenant user(s).
    */

package/ts/ts_smartdb/service-types.ts

@@ -45,6 +45,33 @@ export type TLocalSmartDbOfflineStringValueInspectionResult =
   | { status: 'not-found' }
   | { status: 'found'; value: string };
 
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits {
+  maximumEntries: number;
+  maximumDatabases: number;
+  maximumCollections: number;
+  maximumIndexes: number;
+  maximumDataFileBytes: number;
+  maximumWalFileBytes: number;
+  maximumIndexFileBytes: number;
+  maximumTotalFileBytes: number;
+  maximumRecordsPerCollection: number;
+  maximumRecordBytes: number;
+  maximumResultBytes: number;
+}
+
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspection {
+  folderPath: string;
+  limits: ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits;
+}
+
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspectionResult {
+  schemaVersion: 1;
+  databases: Array<{
+    name: string;
+    collections: string[];
+  }>;
+}
+
 export const smartDbResourceFenceErrorCodes = [
   'EFENCE_REQUIRED',
   'EFENCE_STALE',
@@ -302,6 +329,17 @@ export interface ISmartDbEnsureDatabaseTenantInput
   allocation?: ISmartDbDatabaseAllocationIdentity;
 }
 
+export interface ISmartDbAttestDatabaseTenantInput {
+  databaseName: string;
+  username: string;
+  roles: string[];
+  password: string;
+}
+
+export interface ISmartDbAttestDatabaseTenantResult {
+  matches: boolean;
+}
+
 export interface ISmartDbAllocateDatabaseTenantInput
   extends ISmartDbDatabaseTenantInput {
   expectedAbsent: true;