@topgunbuild/core 0.2.0 → 0.3.0

package/dist/index.js

@@ -21,8 +21,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AuthMessageSchema: () => AuthMessageSchema,
+  BatchMessageSchema: () => BatchMessageSchema,
   ClientOpMessageSchema: () => ClientOpMessageSchema,
   ClientOpSchema: () => ClientOpSchema,
+  ConsistencyLevel: () => ConsistencyLevel,
+  DEFAULT_BACKUP_COUNT: () => DEFAULT_BACKUP_COUNT,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG: () => DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  DEFAULT_CONNECTION_POOL_CONFIG: () => DEFAULT_CONNECTION_POOL_CONFIG,
+  DEFAULT_MIGRATION_CONFIG: () => DEFAULT_MIGRATION_CONFIG,
+  DEFAULT_PARTITION_ROUTER_CONFIG: () => DEFAULT_PARTITION_ROUTER_CONFIG,
+  DEFAULT_REPLICATION_CONFIG: () => DEFAULT_REPLICATION_CONFIG,
+  DEFAULT_WRITE_CONCERN_TIMEOUT: () => DEFAULT_WRITE_CONCERN_TIMEOUT,
   HLC: () => HLC,
   LWWMap: () => LWWMap,
   LWWRecordSchema: () => LWWRecordSchema,
@@ -42,7 +51,13 @@ __export(index_exports, {
   ORMapSyncRespBucketsSchema: () => ORMapSyncRespBucketsSchema,
   ORMapSyncRespLeafSchema: () => ORMapSyncRespLeafSchema,
   ORMapSyncRespRootSchema: () => ORMapSyncRespRootSchema,
+  OpAckMessageSchema: () => OpAckMessageSchema,
   OpBatchMessageSchema: () => OpBatchMessageSchema,
+  OpRejectedMessageSchema: () => OpRejectedMessageSchema,
+  OpResultSchema: () => OpResultSchema,
+  PARTITION_COUNT: () => PARTITION_COUNT,
+  PartitionMapRequestSchema: () => PartitionMapRequestSchema,
+  PartitionState: () => PartitionState,
   PingMessageSchema: () => PingMessageSchema,
   PongMessageSchema: () => PongMessageSchema,
   PredicateNodeSchema: () => PredicateNodeSchema,
@@ -60,13 +75,21 @@ __export(index_exports, {
   TopicPubSchema: () => TopicPubSchema,
   TopicSubSchema: () => TopicSubSchema,
   TopicUnsubSchema: () => TopicUnsubSchema,
+  WRITE_CONCERN_ORDER: () => WRITE_CONCERN_ORDER,
+  WriteConcern: () => WriteConcern,
+  WriteConcernSchema: () => WriteConcernSchema,
   combineHashes: () => combineHashes,
   compareTimestamps: () => compareTimestamps,
   deserialize: () => deserialize,
+  disableNativeHash: () => disableNativeHash,
   evaluatePredicate: () => evaluatePredicate,
+  getHighestWriteConcernLevel: () => getHighestWriteConcernLevel,
   hashORMapEntry: () => hashORMapEntry,
   hashORMapRecord: () => hashORMapRecord,
   hashString: () => hashString,
+  isUsingNativeHash: () => isUsingNativeHash,
+  isWriteConcernAchieved: () => isWriteConcernAchieved,
+  resetNativeHash: () => resetNativeHash,
   serialize: () => serialize,
   timestampToString: () => timestampToString
 });
@@ -161,7 +184,17 @@ _HLC.MAX_DRIFT = 6e4;
 var HLC = _HLC;
 
 // src/utils/hash.ts
-function hashString(str) {
+var nativeHash = null;
+var nativeLoadAttempted = false;
+function tryLoadNative() {
+  if (nativeLoadAttempted) return;
+  nativeLoadAttempted = true;
+  try {
+    nativeHash = require("@topgunbuild/native");
+  } catch {
+  }
+}
+function fnv1aHash(str) {
   let hash = 2166136261;
   for (let i = 0; i < str.length; i++) {
     hash ^= str.charCodeAt(i);
@@ -169,6 +202,13 @@ function hashString(str) {
   }
   return hash >>> 0;
 }
+function hashString(str) {
+  tryLoadNative();
+  if (nativeHash && nativeHash.isNativeHashAvailable()) {
+    return nativeHash.hashString(str);
+  }
+  return fnv1aHash(str);
+}
 function combineHashes(hashes) {
   let result = 0;
   for (const h of hashes) {
@@ -176,6 +216,18 @@ function combineHashes(hashes) {
   }
   return result >>> 0;
 }
+function isUsingNativeHash() {
+  tryLoadNative();
+  return nativeHash?.isNativeHashAvailable() === true;
+}
+function disableNativeHash() {
+  nativeHash = null;
+  nativeLoadAttempted = true;
+}
+function resetNativeHash() {
+  nativeHash = null;
+  nativeLoadAttempted = false;
+}
 
 // src/MerkleTree.ts
 var MerkleTree = class {
@@ -999,12 +1051,13 @@ var ORMap = class {
 };
 
 // src/serializer.ts
-var import_msgpack = require("@msgpack/msgpack");
+var import_msgpackr = require("msgpackr");
 function serialize(data) {
-  return (0, import_msgpack.encode)(data);
+  return (0, import_msgpackr.pack)(data);
 }
 function deserialize(data) {
-  return (0, import_msgpack.decode)(data);
+  const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+  return (0, import_msgpackr.unpack)(buffer);
 }
 
 // src/predicate.ts
@@ -1095,9 +1148,16 @@ function evaluatePredicate(predicate, data) {
 
 // src/schemas.ts
 var import_zod = require("zod");
+var WriteConcernSchema = import_zod.z.enum([
+  "FIRE_AND_FORGET",
+  "MEMORY",
+  "APPLIED",
+  "REPLICATED",
+  "PERSISTED"
+]);
 var TimestampSchema = import_zod.z.object({
-  millis: import_zod.z.number(),
-  counter: import_zod.z.number(),
+  millis: import_zod.z.union([import_zod.z.number(), import_zod.z.bigint()]).transform(Number),
+  counter: import_zod.z.union([import_zod.z.number(), import_zod.z.bigint()]).transform(Number),
   nodeId: import_zod.z.string()
 });
 var LWWRecordSchema = import_zod.z.object({
@@ -1146,7 +1206,10 @@ var ClientOpSchema = import_zod.z.object({
   opType: import_zod.z.string().optional(),
   record: LWWRecordSchema.nullable().optional(),
   orRecord: ORMapRecordSchema.nullable().optional(),
-  orTag: import_zod.z.string().nullable().optional()
+  orTag: import_zod.z.string().nullable().optional(),
+  // Write Concern fields (Phase 5.01)
+  writeConcern: WriteConcernSchema.optional(),
+  timeout: import_zod.z.number().optional()
 });
 var AuthMessageSchema = import_zod.z.object({
   type: import_zod.z.literal("AUTH"),
@@ -1173,7 +1236,10 @@ var ClientOpMessageSchema = import_zod.z.object({
 var OpBatchMessageSchema = import_zod.z.object({
   type: import_zod.z.literal("OP_BATCH"),
   payload: import_zod.z.object({
-    ops: import_zod.z.array(ClientOpSchema)
+    ops: import_zod.z.array(ClientOpSchema),
+    // Batch-level Write Concern (can be overridden per-op)
+    writeConcern: WriteConcernSchema.optional(),
+    timeout: import_zod.z.number().optional()
   })
 });
 var SyncInitMessageSchema = import_zod.z.object({
@@ -1271,6 +1337,11 @@ var PongMessageSchema = import_zod.z.object({
   serverTime: import_zod.z.number()
   // Server's Date.now() (for clock skew detection)
 });
+var BatchMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("BATCH"),
+  count: import_zod.z.number(),
+  data: import_zod.z.instanceof(Uint8Array)
+});
 var ORMapSyncInitSchema = import_zod.z.object({
   type: import_zod.z.literal("ORMAP_SYNC_INIT"),
   mapName: import_zod.z.string(),
@@ -1344,6 +1415,40 @@ var ORMapPushDiffSchema = import_zod.z.object({
     }))
   })
 });
+var PartitionMapRequestSchema = import_zod.z.object({
+  type: import_zod.z.literal("PARTITION_MAP_REQUEST"),
+  payload: import_zod.z.object({
+    currentVersion: import_zod.z.number().optional()
+  }).optional()
+});
+var OpResultSchema = import_zod.z.object({
+  opId: import_zod.z.string(),
+  success: import_zod.z.boolean(),
+  achievedLevel: WriteConcernSchema,
+  error: import_zod.z.string().optional()
+});
+var OpAckMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("OP_ACK"),
+  payload: import_zod.z.object({
+    /** ID of the last operation in the batch (for backwards compatibility) */
+    lastId: import_zod.z.string(),
+    /** Write Concern level achieved (for simple ACKs) */
+    achievedLevel: WriteConcernSchema.optional(),
+    /** Per-operation results (for batch operations with mixed Write Concern) */
+    results: import_zod.z.array(OpResultSchema).optional()
+  })
+});
+var OpRejectedMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("OP_REJECTED"),
+  payload: import_zod.z.object({
+    /** Operation ID that was rejected */
+    opId: import_zod.z.string(),
+    /** Reason for rejection */
+    reason: import_zod.z.string(),
+    /** Error code */
+    code: import_zod.z.number().optional()
+  })
+});
 var MessageSchema = import_zod.z.discriminatedUnion("type", [
   AuthMessageSchema,
   QuerySubMessageSchema,
@@ -1370,13 +1475,108 @@ var MessageSchema = import_zod.z.discriminatedUnion("type", [
   ORMapSyncRespLeafSchema,
   ORMapDiffRequestSchema,
   ORMapDiffResponseSchema,
-  ORMapPushDiffSchema
+  ORMapPushDiffSchema,
+  // Phase 4: Partition Map
+  PartitionMapRequestSchema
 ]);
+
+// src/types/WriteConcern.ts
+var WriteConcern = /* @__PURE__ */ ((WriteConcern2) => {
+  WriteConcern2["FIRE_AND_FORGET"] = "FIRE_AND_FORGET";
+  WriteConcern2["MEMORY"] = "MEMORY";
+  WriteConcern2["APPLIED"] = "APPLIED";
+  WriteConcern2["REPLICATED"] = "REPLICATED";
+  WriteConcern2["PERSISTED"] = "PERSISTED";
+  return WriteConcern2;
+})(WriteConcern || {});
+var DEFAULT_WRITE_CONCERN_TIMEOUT = 5e3;
+var WRITE_CONCERN_ORDER = [
+  "FIRE_AND_FORGET" /* FIRE_AND_FORGET */,
+  "MEMORY" /* MEMORY */,
+  "APPLIED" /* APPLIED */,
+  "REPLICATED" /* REPLICATED */,
+  "PERSISTED" /* PERSISTED */
+];
+function isWriteConcernAchieved(achieved, target) {
+  const targetIndex = WRITE_CONCERN_ORDER.indexOf(target);
+  const achievedIndex = Math.max(
+    ...Array.from(achieved).map((l) => WRITE_CONCERN_ORDER.indexOf(l))
+  );
+  return achievedIndex >= targetIndex;
+}
+function getHighestWriteConcernLevel(achieved) {
+  for (let i = WRITE_CONCERN_ORDER.length - 1; i >= 0; i--) {
+    if (achieved.has(WRITE_CONCERN_ORDER[i])) {
+      return WRITE_CONCERN_ORDER[i];
+    }
+  }
+  return "FIRE_AND_FORGET" /* FIRE_AND_FORGET */;
+}
+
+// src/types/cluster.ts
+var DEFAULT_CONNECTION_POOL_CONFIG = {
+  maxConnectionsPerNode: 1,
+  connectionTimeoutMs: 5e3,
+  healthCheckIntervalMs: 1e4,
+  reconnectDelayMs: 1e3,
+  maxReconnectDelayMs: 3e4,
+  maxReconnectAttempts: 5
+};
+var DEFAULT_PARTITION_ROUTER_CONFIG = {
+  fallbackMode: "forward",
+  mapRefreshIntervalMs: 3e4,
+  maxMapStalenessMs: 6e4
+};
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeoutMs: 3e4
+};
+var PartitionState = /* @__PURE__ */ ((PartitionState2) => {
+  PartitionState2["STABLE"] = "STABLE";
+  PartitionState2["MIGRATING"] = "MIGRATING";
+  PartitionState2["SYNC"] = "SYNC";
+  PartitionState2["FAILED"] = "FAILED";
+  return PartitionState2;
+})(PartitionState || {});
+var DEFAULT_MIGRATION_CONFIG = {
+  batchSize: 10,
+  batchIntervalMs: 5e3,
+  transferChunkSize: 65536,
+  // 64KB
+  maxRetries: 3,
+  syncTimeoutMs: 3e4,
+  parallelTransfers: 4
+};
+var ConsistencyLevel = /* @__PURE__ */ ((ConsistencyLevel2) => {
+  ConsistencyLevel2["STRONG"] = "STRONG";
+  ConsistencyLevel2["QUORUM"] = "QUORUM";
+  ConsistencyLevel2["EVENTUAL"] = "EVENTUAL";
+  return ConsistencyLevel2;
+})(ConsistencyLevel || {});
+var DEFAULT_REPLICATION_CONFIG = {
+  defaultConsistency: "EVENTUAL" /* EVENTUAL */,
+  queueSizeLimit: 1e4,
+  batchSize: 100,
+  batchIntervalMs: 50,
+  ackTimeoutMs: 5e3,
+  maxRetries: 3
+};
+var PARTITION_COUNT = 271;
+var DEFAULT_BACKUP_COUNT = 1;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthMessageSchema,
+  BatchMessageSchema,
   ClientOpMessageSchema,
   ClientOpSchema,
+  ConsistencyLevel,
+  DEFAULT_BACKUP_COUNT,
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  DEFAULT_CONNECTION_POOL_CONFIG,
+  DEFAULT_MIGRATION_CONFIG,
+  DEFAULT_PARTITION_ROUTER_CONFIG,
+  DEFAULT_REPLICATION_CONFIG,
+  DEFAULT_WRITE_CONCERN_TIMEOUT,
   HLC,
   LWWMap,
   LWWRecordSchema,
@@ -1396,7 +1596,13 @@ var MessageSchema = import_zod.z.discriminatedUnion("type", [
   ORMapSyncRespBucketsSchema,
   ORMapSyncRespLeafSchema,
   ORMapSyncRespRootSchema,
+  OpAckMessageSchema,
   OpBatchMessageSchema,
+  OpRejectedMessageSchema,
+  OpResultSchema,
+  PARTITION_COUNT,
+  PartitionMapRequestSchema,
+  PartitionState,
   PingMessageSchema,
   PongMessageSchema,
   PredicateNodeSchema,
@@ -1414,13 +1620,21 @@ var MessageSchema = import_zod.z.discriminatedUnion("type", [
   TopicPubSchema,
   TopicSubSchema,
   TopicUnsubSchema,
+  WRITE_CONCERN_ORDER,
+  WriteConcern,
+  WriteConcernSchema,
   combineHashes,
   compareTimestamps,
   deserialize,
+  disableNativeHash,
   evaluatePredicate,
+  getHighestWriteConcernLevel,
   hashORMapEntry,
   hashORMapRecord,
   hashString,
+  isUsingNativeHash,
+  isWriteConcernAchieved,
+  resetNativeHash,
   serialize,
   timestampToString
 });