@push.rocks/smartdb 2.12.1 → 2.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdb",
-  "version": "2.12.1",
+  "version": "2.12.3",
   "private": false,
   "description": "A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.",
   "exports": {
@@ -15,11 +15,11 @@
     "@api.global/typedserver": "^8.4.6",
     "@design.estate/dees-element": "^2.2.4",
     "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tsbundle": "^2.10.4",
-    "@git.zone/tsrun": "^2.0.4",
-    "@git.zone/tsrust": "^1.4.1",
+    "@git.zone/tsbundle": "^2.11.2",
+    "@git.zone/tsrun": "^2.0.5",
+    "@git.zone/tsrust": "^1.6.0",
     "@git.zone/tstest": "^3.6.6",
-    "@types/node": "^25.9.1",
+    "@types/node": "^26.1.1",
     "mongodb": "^7.1.1"
   },
   "dependencies": {

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartdb',
-  version: '2.12.1',
+  version: '2.12.3',
   description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 }

package/ts/index.ts

@@ -27,6 +27,8 @@ export type {
   ISmartDbResourceFenceReceipt,
   TSmartDbResourceFenceErrorCode,
   ISmartDbDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantResult,
   ISmartDbDeleteDatabaseTenantInput,
   ISmartDbRotateDatabaseTenantPasswordInput,
   ISmartDbDatabaseTenantDescriptor,
@@ -35,9 +37,11 @@ export type {
   ISmartDbDatabaseExport,
   ISmartDbImportDatabaseInput,
   ISmartDbImportDatabaseResult,
+  TSmartDbEffectivePayloadInputV1,
 } from './ts_smartdb/index.js';
 export {
   SmartDbResourceFenceError,
   normalizeSmartDbResourceFenceError,
   smartDbResourceFenceErrorCodes,
+  createSmartDbEffectivePayloadSha256V1,
 } from './ts_smartdb/index.js';

package/ts/ts_smartdb/index.ts

@@ -31,6 +31,8 @@ export type {
   ISmartDbResourceFenceReceipt,
   TSmartDbResourceFenceErrorCode,
   ISmartDbDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantResult,
   ISmartDbDeleteDatabaseTenantInput,
   ISmartDbRotateDatabaseTenantPasswordInput,
   ISmartDbDatabaseTenantDescriptor,
@@ -45,3 +47,5 @@ export {
   normalizeSmartDbResourceFenceError,
   smartDbResourceFenceErrorCodes,
 } from './service-types.js';
+export type { TSmartDbEffectivePayloadInputV1 } from './resource-fencing.js';
+export { createSmartDbEffectivePayloadSha256V1 } from './resource-fencing.js';

package/ts/ts_smartdb/plugins.ts

@@ -1,3 +1,9 @@
+// node native scope
+import * as buffer from 'node:buffer';
+import * as crypto from 'node:crypto';
+
+export { buffer, crypto };
+
 // @push.rocks scope
 import * as smartrust from '@push.rocks/smartrust';
 

package/ts/ts_smartdb/resource-fencing.ts

@@ -0,0 +1,286 @@
+import * as plugins from './plugins.js';
+import type { ISmartDbDatabaseExport } from './service-types.js';
+
+export type TSmartDbEffectivePayloadInputV1 =
+  | {
+      version: 1;
+      kind: 'smartdb.database.replace.v1';
+      databaseName: string;
+      source: ISmartDbDatabaseExport;
+      /** Exact exclusive tenant owner; omission retains the legacy v1 digest. */
+      username?: string;
+    }
+  | {
+      version: 1;
+      kind: 'smartdb.database.delete.v1';
+      databaseName: string;
+      username: string;
+    }
+  | {
+      version: 1;
+      kind: 'smartdb.database.ensure.v1';
+      databaseName: string;
+      username: string;
+      password: string;
+      roles?: string[];
+    };
+
+type TCanonicalJsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | TCanonicalJsonValue[]
+  | { [key: string]: TCanonicalJsonValue };
+
+const typedPayloadPrefix = plugins.buffer.Buffer.from(
+  'smartdb.effective-payload.typed.v1\0',
+  'utf8',
+);
+const minimumI64 = -9_223_372_036_854_775_808n;
+const maximumU64 = 18_446_744_073_709_551_615n;
+
+const compareUtf8Keys = (leftArg: string, rightArg: string): number =>
+  plugins.buffer.Buffer.compare(
+    plugins.buffer.Buffer.from(leftArg, 'utf8'),
+    plugins.buffer.Buffer.from(rightArg, 'utf8'),
+  );
+
+const formatSerdeJsonFloat = (valueArg: number): string => {
+  const transportNumber = JSON.stringify(valueArg);
+  if (/^-?\d+$/.test(transportNumber)) {
+    const integer = BigInt(transportNumber);
+    if (integer >= minimumI64 && integer <= maximumU64) {
+      return transportNumber;
+    }
+  }
+
+  const negative = valueArg < 0;
+  const source = Math.abs(valueArg).toString().toLowerCase();
+  let digits: string;
+  let decimalExponent: number;
+  if (source.includes('e')) {
+    const [coefficient, exponent] = source.split('e');
+    digits = coefficient.replace('.', '').replace(/^0+|0+$/g, '');
+    decimalExponent = Number.parseInt(exponent, 10);
+  } else {
+    const [integerPart, fractionPart = ''] = source.split('.');
+    const rawDigits = `${integerPart}${fractionPart}`;
+    const firstSignificant = rawDigits.search(/[1-9]/);
+    const lastSignificant = rawDigits.search(/[1-9](?!.*[1-9])/);
+    if (firstSignificant < 0) {
+      return '0.0';
+    }
+    digits = rawDigits.slice(firstSignificant, lastSignificant + 1);
+    decimalExponent = integerPart.length - firstSignificant - 1;
+  }
+
+  let rendered: string;
+  if (decimalExponent >= -5 && decimalExponent <= 15) {
+    const integerDigits = decimalExponent + 1;
+    if (digits.length <= integerDigits) {
+      rendered = `${digits}${'0'.repeat(integerDigits - digits.length)}.0`;
+    } else if (integerDigits > 0) {
+      rendered = `${digits.slice(0, integerDigits)}.${digits.slice(integerDigits)}`;
+    } else {
+      rendered = `0.${'0'.repeat(-integerDigits)}${digits}`;
+    }
+  } else {
+    const significand =
+      digits.length === 1 ? digits : `${digits[0]}.${digits.slice(1)}`;
+    rendered = `${significand}e${decimalExponent >= 0 ? '+' : ''}${decimalExponent}`;
+  }
+  return negative ? `-${rendered}` : rendered;
+};
+
+const canonicalJsonStringify = (valueArg: TCanonicalJsonValue): string => {
+  if (typeof valueArg === 'number') {
+    return formatSerdeJsonFloat(valueArg);
+  }
+  if (valueArg === null || typeof valueArg !== 'object') {
+    const serialized = JSON.stringify(valueArg);
+    if (serialized === undefined) {
+      throw new TypeError('SmartDB effective payload contains unsupported JSON');
+    }
+    return serialized;
+  }
+  if (Array.isArray(valueArg)) {
+    return `[${valueArg.map((entryArg) => canonicalJsonStringify(entryArg)).join(',')}]`;
+  }
+  return `{${Object.keys(valueArg)
+    .map(
+      (keyArg) =>
+        `${JSON.stringify(keyArg)}:${canonicalJsonStringify(valueArg[keyArg])}`,
+    )
+    .join(',')}}`;
+};
+
+const encodeTypedLength = (lengthArg: number): Uint8Array => {
+  const encoded = plugins.buffer.Buffer.allocUnsafe(8);
+  encoded.writeBigUInt64BE(BigInt(lengthArg));
+  return encoded;
+};
+
+const encodeTypedBytes = (valueArg: Uint8Array): Uint8Array[] => [
+  encodeTypedLength(valueArg.byteLength),
+  valueArg,
+];
+
+const encodeTypedValue = (
+  valueArg: TCanonicalJsonValue,
+  chunksArg: Uint8Array[],
+): void => {
+  if (valueArg === null) {
+    chunksArg.push(plugins.buffer.Buffer.from([0]));
+    return;
+  }
+  if (valueArg === false) {
+    chunksArg.push(plugins.buffer.Buffer.from([1]));
+    return;
+  }
+  if (valueArg === true) {
+    chunksArg.push(plugins.buffer.Buffer.from([2]));
+    return;
+  }
+  if (typeof valueArg === 'number') {
+    if (!Number.isFinite(valueArg)) {
+      throw new TypeError('SmartDB exact replace contains a non-finite number');
+    }
+    const encoded = plugins.buffer.Buffer.allocUnsafe(9);
+    encoded[0] = 3;
+    encoded.writeDoubleBE(valueArg, 1);
+    chunksArg.push(encoded);
+    return;
+  }
+  if (typeof valueArg === 'string') {
+    const encoded = plugins.buffer.Buffer.from(valueArg, 'utf8');
+    chunksArg.push(plugins.buffer.Buffer.from([4]), ...encodeTypedBytes(encoded));
+    return;
+  }
+  if (Array.isArray(valueArg)) {
+    chunksArg.push(
+      plugins.buffer.Buffer.from([5]),
+      encodeTypedLength(valueArg.length),
+    );
+    for (const value of valueArg) {
+      encodeTypedValue(value, chunksArg);
+    }
+    return;
+  }
+  const keys = Object.keys(valueArg).sort(compareUtf8Keys);
+  chunksArg.push(
+    plugins.buffer.Buffer.from([6]),
+    encodeTypedLength(keys.length),
+  );
+  for (const key of keys) {
+    const encodedKey = plugins.buffer.Buffer.from(key, 'utf8');
+    chunksArg.push(
+      plugins.buffer.Buffer.from([4]),
+      ...encodeTypedBytes(encodedKey),
+    );
+    encodeTypedValue(valueArg[key], chunksArg);
+  }
+};
+
+const encodeTypedPayload = (valueArg: TCanonicalJsonValue): Uint8Array => {
+  const chunks: Uint8Array[] = [typedPayloadPrefix];
+  encodeTypedValue(valueArg, chunks);
+  return plugins.buffer.Buffer.concat(chunks);
+};
+
+/**
+ * Computes the provider-derived SHA-256 identity for SmartDB's version 1
+ * fenced replace, exact-user delete, and exact-user ensure payload profiles.
+ */
+export const createSmartDbEffectivePayloadSha256V1 = (
+  inputArg: TSmartDbEffectivePayloadInputV1,
+): string => {
+  if (inputArg.version !== 1) {
+    throw new TypeError('SmartDB effective payload version must be 1');
+  }
+  if (typeof inputArg.databaseName !== 'string') {
+    throw new TypeError('SmartDB effective payload databaseName must be a string');
+  }
+
+  let effectivePayload: object;
+  let useTypedEncoding = false;
+  switch (inputArg.kind) {
+    case 'smartdb.database.replace.v1':
+      if (
+        inputArg.username !== undefined &&
+        typeof inputArg.username !== 'string'
+      ) {
+        throw new TypeError('SmartDB exact replace username must be a string');
+      }
+      effectivePayload = {
+        version: 1,
+        kind: inputArg.kind,
+        databaseName: inputArg.databaseName,
+        source: inputArg.source,
+        ...(inputArg.username === undefined
+          ? {}
+          : { username: inputArg.username }),
+      };
+      useTypedEncoding = inputArg.username !== undefined;
+      break;
+    case 'smartdb.database.ensure.v1': {
+      if (typeof inputArg.username !== 'string') {
+        throw new TypeError('SmartDB exact ensure username must be a string');
+      }
+      if (typeof inputArg.password !== 'string') {
+        throw new TypeError('SmartDB exact ensure password must be a string');
+      }
+      const roles = inputArg.roles ?? ['readWrite', 'dbAdmin'];
+      if (
+        !Array.isArray(roles) ||
+        roles.some(
+          (roleArg) => typeof roleArg !== 'string' || roleArg.length === 0,
+        )
+      ) {
+        throw new TypeError(
+          'SmartDB exact ensure roles must be an array of non-empty strings',
+        );
+      }
+      const canonicalRoles = [...new Set(roles)].sort(compareUtf8Keys);
+      effectivePayload = {
+        version: 1,
+        kind: inputArg.kind,
+        databaseName: inputArg.databaseName,
+        username: inputArg.username,
+        passwordSha256: plugins.crypto
+          .createHash('sha256')
+          .update(inputArg.password, 'utf8')
+          .digest('hex'),
+        roles: canonicalRoles,
+      };
+      break;
+    }
+    case 'smartdb.database.delete.v1':
+      if (typeof inputArg.username !== 'string') {
+        throw new TypeError('SmartDB exact delete username must be a string');
+      }
+      effectivePayload = {
+        version: 1,
+        kind: inputArg.kind,
+        databaseName: inputArg.databaseName,
+        username: inputArg.username,
+        rawDatabaseOnly: false,
+      };
+      break;
+    default:
+      throw new TypeError('SmartDB mutation kind has no version 1 payload profile');
+  }
+
+  const transportJson = JSON.stringify(effectivePayload);
+  if (transportJson === undefined) {
+    throw new TypeError('SmartDB effective payload cannot be encoded as JSON');
+  }
+  const normalizedPayload = JSON.parse(transportJson) as TCanonicalJsonValue;
+  const encodedPayload = useTypedEncoding
+    ? encodeTypedPayload(normalizedPayload)
+    : canonicalJsonStringify(normalizedPayload);
+  return plugins.crypto
+    .createHash('sha256')
+    .update(encodedPayload)
+    .digest('hex');
+};

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

@@ -6,6 +6,8 @@ import { normalizeSmartDbResourceFenceError } from './service-types.js';
 import type {
   ISmartDbHealth,
   ISmartDbDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantResult,
   ISmartDbDeleteDatabaseTenantInput,
   ISmartDbRotateDatabaseTenantPasswordInput,
   ISmartDbDatabaseTenantDescriptor,
@@ -18,6 +20,8 @@ import type {
 export type {
   ISmartDbHealth,
   ISmartDbDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantResult,
   ISmartDbDeleteDatabaseTenantInput,
   ISmartDbRotateDatabaseTenantPasswordInput,
   ISmartDbDatabaseTenantDescriptor,
@@ -123,6 +127,10 @@ type TSmartDbCommands = {
     params: ISmartDbDatabaseTenantInput;
     result: ISmartDbDatabaseTenantDescriptor;
   };
+  ensureDatabaseTenant: {
+    params: ISmartDbEnsureDatabaseTenantInput;
+    result: ISmartDbEnsureDatabaseTenantResult;
+  };
   deleteDatabaseTenant: {
     params: ISmartDbDeleteDatabaseTenantInput;
     result: ISmartDbDeleteDatabaseTenantResult;
@@ -246,6 +254,14 @@ function buildLocalPaths(): string[] {
 
   return paths;
 }
+export function getRustDbAllocatorEnv(
+  environment: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+  return {
+    MIMALLOC_ARENA_EAGER_COMMIT: environment.MIMALLOC_ARENA_EAGER_COMMIT ?? '0',
+    MIMALLOC_ALLOW_LARGE_OS_PAGES: environment.MIMALLOC_ALLOW_LARGE_OS_PAGES ?? '0',
+  };
+}
 
 /**
  * Bridge between TypeScript SmartdbServer and the Rust binary.
@@ -263,6 +279,7 @@ export class RustDbBridge extends EventEmitter {
       platformPackagePrefix: '@push.rocks/smartdb',
       localPaths: buildLocalPaths(),
       maxPayloadSize: 100 * 1024 * 1024, // database exports/imports can be larger than command replies
+      env: getRustDbAllocatorEnv(),
     });
 
     // Forward events from the inner bridge
@@ -318,7 +335,21 @@ export class RustDbBridge extends EventEmitter {
   public async createDatabaseTenant(
     params: ISmartDbDatabaseTenantInput,
   ): Promise<ISmartDbDatabaseTenantDescriptor> {
-    return this.bridge.sendCommand('createDatabaseTenant', params) as Promise<ISmartDbDatabaseTenantDescriptor>;
+    try {
+      return await this.bridge.sendCommand('createDatabaseTenant', params) as ISmartDbDatabaseTenantDescriptor;
+    } catch (error) {
+      throw normalizeSmartDbResourceFenceError(error);
+    }
+  }
+
+  public async ensureDatabaseTenant(
+    params: ISmartDbEnsureDatabaseTenantInput,
+  ): Promise<ISmartDbEnsureDatabaseTenantResult> {
+    try {
+      return await this.bridge.sendCommand('ensureDatabaseTenant', params) as ISmartDbEnsureDatabaseTenantResult;
+    } catch (error) {
+      throw normalizeSmartDbResourceFenceError(error);
+    }
   }
 
   public async deleteDatabaseTenant(

package/ts/ts_smartdb/server/SmartdbServer.ts

@@ -12,6 +12,8 @@ import type {
 import type {
   ISmartDbHealth,
   ISmartDbDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantInput,
+  ISmartDbEnsureDatabaseTenantResult,
   ISmartDbDeleteDatabaseTenantInput,
   ISmartDbRotateDatabaseTenantPasswordInput,
   ISmartDbDatabaseTenantDescriptor,
@@ -236,6 +238,16 @@ export class SmartdbServer {
     return this.withTenantMongoUri(descriptor, params.password);
   }
 
+  /**
+   * Idempotently provision or rotate one exclusively owned database tenant.
+   */
+  async ensureDatabaseTenant(
+    params: ISmartDbEnsureDatabaseTenantInput,
+  ): Promise<ISmartDbEnsureDatabaseTenantResult> {
+    const descriptor = await this.bridge.ensureDatabaseTenant(params);
+    return this.withTenantMongoUri(descriptor, params.password);
+  }
+
   /**
    * Delete a tenant database and its tenant user(s).
    */
@@ -363,10 +375,10 @@ export class SmartdbServer {
     return this.bridge.getMetrics();
   }
 
-  private withTenantMongoUri(
-    descriptor: ISmartDbDatabaseTenantDescriptor,
+  private withTenantMongoUri<TDescriptor extends ISmartDbDatabaseTenantDescriptor>(
+    descriptor: TDescriptor,
     password: string,
-  ): ISmartDbDatabaseTenantDescriptor {
+  ): TDescriptor & { mongodbUri: string } {
     return {
       ...descriptor,
       mongodbUri: this.buildTenantMongoUri(descriptor.databaseName, descriptor.username, password),

package/ts/ts_smartdb/service-types.ts

@@ -19,6 +19,7 @@ export const smartDbResourceFenceErrorCodes = [
   'EFENCE_SCOPE_MISMATCH',
   'EFENCE_UNSUPPORTED',
   'EFENCE_MUTATION_MISMATCH',
+  'EFENCE_OWNERSHIP_MISMATCH',
   'EFENCE_STATE_CORRUPT',
   'EFENCE_RECEIPT_LIMIT',
   'EFENCE_BUSY',
@@ -39,7 +40,8 @@ export interface ISmartDbResourceFenceReceipt
   extends ISmartDbResourceFence {
   kind:
     | 'smartdb.database.replace.v1'
-    | 'smartdb.database.delete.v1';
+    | 'smartdb.database.delete.v1'
+    | 'smartdb.database.ensure.v1';
   /** Digest of the canonical payload interpretation derived by SmartDB. */
   effectivePayloadSha256: string;
 }
@@ -88,6 +90,11 @@ export interface ISmartDbDatabaseTenantInput {
   roles?: string[];
 }
 
+export interface ISmartDbEnsureDatabaseTenantInput
+  extends ISmartDbDatabaseTenantInput {
+  fence: ISmartDbResourceFence;
+}
+
 export interface ISmartDbDeleteDatabaseTenantInput {
   databaseName: string;
   /**
@@ -95,7 +102,8 @@ export interface ISmartDbDeleteDatabaseTenantInput {
    * included in the durable mutation and is removed idempotently after the
    * database deletion is durable. Omitting it from a fenced deletion
    * preserves auth users; an unfenced omission retains the legacy behavior
-   * of deleting every user for the database.
+   * of deleting every user for the database. If the database exists, a
+   * fenced deletion fails closed unless this exact user currently owns it.
    */
   username?: string;
   fence?: ISmartDbResourceFence;
@@ -112,6 +120,12 @@ export interface ISmartDbDatabaseTenantDescriptor {
   roles: string[];
   authSource: string;
   mongodbUri?: string;
+  resourceFence?: ISmartDbResourceFenceReceipt;
+}
+
+export interface ISmartDbEnsureDatabaseTenantResult
+  extends ISmartDbDatabaseTenantDescriptor {
+  resourceFence: ISmartDbResourceFenceReceipt;
 }
 
 export interface ISmartDbDeleteDatabaseTenantResult {
@@ -147,6 +161,12 @@ export interface ISmartDbDatabaseExport {
 export interface ISmartDbImportDatabaseInput {
   databaseName: string;
   source: ISmartDbDatabaseExport;
+  /**
+   * Exact exclusive tenant owner required for this replacement. When used
+   * with a fence, the username is included in the provider-derived mutation
+   * identity. Omission preserves the original version 1 replacement profile.
+   */
+  username?: string;
   fence?: ISmartDbResourceFence;
 }