@arcote.tech/arc 0.1.8 → 0.1.9

package/dist/index.js

@@ -43,6 +43,19 @@ class ArcOptional {
       anyOf: [parentSchema, { type: "null" }]
     };
   }
+  getColumnData() {
+    const parentColumnData = this.parent.getColumnData?.();
+    if (!parentColumnData) {
+      throw new Error(`Parent element does not implement getColumnData()`);
+    }
+    return {
+      ...parentColumnData,
+      storeData: {
+        ...parentColumnData.storeData,
+        isNullable: true
+      }
+    };
+  }
 }
 
 // elements/branded.ts
@@ -71,6 +84,13 @@ class ArcBranded {
   toJsonSchema() {
     return this.parent.toJsonSchema?.() ?? {};
   }
+  getColumnData() {
+    const parentColumnData = this.parent.getColumnData?.();
+    if (!parentColumnData) {
+      throw new Error(`Parent element does not implement getColumnData()`);
+    }
+    return parentColumnData;
+  }
 }
 
 // elements/default.ts
@@ -111,12 +131,24 @@ class ArcDefault {
       default: defaultValue
     };
   }
+  getColumnData() {
+    const parentColumnData = this.parent.getColumnData?.();
+    if (!parentColumnData) {
+      throw new Error(`Parent element does not implement getColumnData()`);
+    }
+    const defaultValue = typeof this.defaultValueOrCallback === "function" ? this.defaultValueOrCallback() : this.defaultValueOrCallback;
+    return {
+      ...parentColumnData,
+      defaultValue
+    };
+  }
 }
 
 // elements/abstract.ts
 class ArcAbstract {
   validations;
   _description;
+  _storeData;
   constructor(validations = []) {
     this.validations = validations;
   }
@@ -138,6 +170,7 @@ class ArcAbstract {
     const Constructor = this.constructor;
     const newInstance = Object.assign(new Constructor, this);
     newInstance._description = this._description;
+    newInstance._storeData = this._storeData ? { ...this._storeData } : undefined;
     return newInstance;
   }
   validate(value) {
@@ -169,194 +202,54 @@ class ArcAbstract {
   getValidations() {
     return this.validations;
   }
-}
-
-// elements/abstract-primitive.ts
-class ArcPrimitive extends ArcAbstract {
-  serialize(value) {
-    return value;
-  }
-  parse(value) {
-    return value;
-  }
-  deserialize(value) {
-    return value;
-  }
-}
-
-// elements/utils/type-validator-builder.ts
-function primitiveTypeComparatorStrategyFactory(type) {
-  return (value) => typeof value === type;
-}
-function typeValidatorBuilder(typeName, comparatorStrategy) {
-  const comparator = comparatorStrategy || primitiveTypeComparatorStrategyFactory(typeName);
-  return {
-    name: "type",
-    validator: (value) => {
-      const valueType = typeof value;
-      if (!comparator(value))
-        return { current: valueType, expected: typeName };
-      return false;
-    }
-  };
-}
-
-// elements/string.ts
-var stringValidator = typeValidatorBuilder("string");
-
-class ArcString extends ArcPrimitive {
-  constructor() {
-    super([stringValidator]);
-  }
-  minLength(min) {
-    return this.validation("minLength", (value) => {
-      if (value.length < min)
-        return {
-          currentLength: value.length,
-          minLength: min
-        };
-    });
-  }
-  maxLength(max) {
-    return this.validation("maxLength", (value) => {
-      if (value.length > max)
-        return {
-          currentLength: value.length,
-          maxLength: max
-        };
-    });
-  }
-  length(number) {
-    return this.validation("length", (value) => {
-      if (value.length !== number) {
-        return {
-          currentLength: value.length,
-          length: number
-        };
-      }
-    });
-  }
-  includes(str) {
-    return this.validation("includes", (value) => {
-      if (!value.includes(str)) {
-        return {
-          currentValue: value,
-          includes: str
-        };
-      }
-    });
-  }
-  startsWith(str) {
-    return this.validation("startsWith", (value) => {
-      if (!value.startsWith(str)) {
-        return {
-          currentValue: value,
-          startsWith: str
-        };
-      }
-    });
-  }
-  endsWith(str) {
-    return this.validation("endsWith", (value) => {
-      if (!value.endsWith(str)) {
-        return {
-          currentValue: value,
-          endsWith: str
-        };
-      }
-    });
-  }
-  regex(regex) {
-    return this.validation("regex", (value) => {
-      if (!regex.test(value)) {
-        return {
-          currentValue: value,
-          regex
-        };
-      }
-    });
-  }
-  email() {
-    const regex = /^(?:(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+)*)|(?:"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f])*"))@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$|(?:\[(?:\d{1,3}\.){3}\d{1,3}\])$/;
-    return this.validation("email", (value) => {
-      if (!regex.test(value)) {
-        return {
-          currentEmail: value
-        };
-      }
-    });
-  }
-  toJsonSchema() {
-    const schema = { type: "string" };
-    if (this._description) {
-      schema.description = this._description;
-    }
-    return schema;
+  primaryKey() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, isPrimaryKey: true };
+    return clone;
   }
-  url() {
-    const regex = /^(https?):\/\/(?![-0-9])(?!www\.[0-9])(?:[a-zA-Z0-9-]+(?::[a-zA-Z0-9-]+)?@)?(?:localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b|[a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.(?:[a-zA-Z]{2,}|[a-zA-Z]{2}\.[a-zA-Z]{2})(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$|^(https?):\/\/(localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b)(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$/;
-    return this.validation("url", (value) => {
-      if (!regex.test(value)) {
-        return {
-          currentUrl: value
-        };
-      }
-    });
+  autoIncrement() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, isAutoIncrement: true };
+    return clone;
   }
-  ip() {
-    const IPv4regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-    const IPv6regex = /^(?:([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|:(:[0-9a-fA-F]{1,4}){1,7}|([0-9a-fA-F]{1,4}:){1,6}:([0-9a-fA-F]{1,4}:){1,6}[0-9a-fA-F]{1,4})$/;
-    return this.validation("ip", (value) => {
-      if (!(IPv4regex.test(value) || IPv6regex.test(value))) {
-        return {
-          currentIP: value
-        };
-      }
-    });
+  unique() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, isUnique: true };
+    return clone;
   }
-  validation(name, validator) {
-    const instance = this.pipeValidation(name, validator);
-    return instance;
+  index() {
+    const clone = this.clone();
+    clone._storeData = { ...clone._storeData, hasIndex: true };
+    return clone;
   }
-}
-function string() {
-  return new ArcString;
-}
-
-// elements/id.ts
-class ArcCustomId extends ArcBranded {
-  createFn;
-  constructor(name, createFn) {
-    super(string(), name);
-    this.createFn = createFn;
+  foreignKey(table, column, options) {
+    const clone = this.clone();
+    clone._storeData = {
+      ...clone._storeData,
+      foreignKey: { table, column, ...options }
+    };
+    return clone;
   }
-  get(...args) {
-    return this.createFn(...args);
+  databaseType(overrides) {
+    const clone = this.clone();
+    clone._storeData = {
+      ...clone._storeData,
+      databaseType: { ...clone._storeData?.databaseType, ...overrides }
+    };
+    return clone;
   }
-}
-
-class ArcId extends ArcBranded {
-  generateFn;
-  constructor(name, generateFn) {
-    super(string(), name);
-    this.generateFn = generateFn;
+  columnOptions(options) {
+    const clone = this.clone();
+    clone._storeData = {
+      ...clone._storeData,
+      columnOptions: { ...clone._storeData?.columnOptions, ...options }
+    };
+    return clone;
   }
-  generate() {
-    if (this.generateFn) {
-      return this.generateFn();
-    }
-    var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
-    return timestamp + "xxxxxxxxxxxxxxxx".replace(/[x]/g, function() {
-      return (Math.random() * 16 | 0).toString(16);
-    }).toLowerCase();
+  getStoreData() {
+    return this._storeData;
   }
 }
-function id(name, generateFn) {
-  return new ArcId(name, generateFn);
-}
-function customId(name, createFn) {
-  return new ArcCustomId(name, createFn);
-}
 
 // elements/any.ts
 class ArcAny extends ArcAbstract {
@@ -379,10 +272,37 @@ class ArcAny extends ArcAbstract {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "object",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
 }
 function any() {
   return new ArcAny;
 }
+// elements/utils/type-validator-builder.ts
+function primitiveTypeComparatorStrategyFactory(type) {
+  return (value) => typeof value === type;
+}
+function typeValidatorBuilder(typeName, comparatorStrategy) {
+  const comparator = comparatorStrategy || primitiveTypeComparatorStrategyFactory(typeName);
+  return {
+    name: "type",
+    validator: (value) => {
+      const valueType = typeof value;
+      if (!comparator(value))
+        return { current: valueType, expected: typeName };
+      return false;
+    }
+  };
+}
+
 // elements/object.ts
 var objectValidator = typeValidatorBuilder("object");
 
@@ -514,6 +434,20 @@ class ArcObject extends ArcAbstract {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "object",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
+  merge(otherShape) {
+    const mergedShape = { ...this.rawShape, ...otherShape };
+    return new ArcObject(mergedShape);
+  }
 }
 function object(element) {
   return new ArcObject(element);
@@ -613,10 +547,33 @@ class ArcArray extends ArcAbstract {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "array",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
 }
 function array(element) {
   return new ArcArray(element);
 }
+// elements/abstract-primitive.ts
+class ArcPrimitive extends ArcAbstract {
+  serialize(value) {
+    return value;
+  }
+  parse(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+}
+
 // elements/blob.ts
 var blobValidator = {
   name: "blob",
@@ -715,8 +672,18 @@ class ArcBlob extends ArcPrimitive {
     }
     return schema;
   }
-}
-function blob() {
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "blob",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
+}
+function blob() {
   return new ArcBlob;
 }
 // elements/boolean.ts
@@ -740,6 +707,16 @@ class ArcBoolean extends ArcPrimitive {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "boolean",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
 }
 function boolean() {
   return new ArcBoolean;
@@ -789,6 +766,16 @@ class ArcDate extends ArcAbstract {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "date",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
 }
 function date() {
   return new ArcDate;
@@ -967,10 +954,207 @@ class ArcFile extends ArcPrimitive {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "blob",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
 }
 function file() {
   return new ArcFile;
 }
+// elements/string.ts
+var stringValidator = typeValidatorBuilder("string");
+
+class ArcString extends ArcPrimitive {
+  constructor() {
+    super([stringValidator]);
+  }
+  minLength(min) {
+    return this.validation("minLength", (value) => {
+      if (value.length < min)
+        return {
+          currentLength: value.length,
+          minLength: min
+        };
+    });
+  }
+  maxLength(max) {
+    return this.validation("maxLength", (value) => {
+      if (value.length > max)
+        return {
+          currentLength: value.length,
+          maxLength: max
+        };
+    });
+  }
+  length(number) {
+    return this.validation("length", (value) => {
+      if (value.length !== number) {
+        return {
+          currentLength: value.length,
+          length: number
+        };
+      }
+    });
+  }
+  includes(str) {
+    return this.validation("includes", (value) => {
+      if (!value.includes(str)) {
+        return {
+          currentValue: value,
+          includes: str
+        };
+      }
+    });
+  }
+  startsWith(str) {
+    return this.validation("startsWith", (value) => {
+      if (!value.startsWith(str)) {
+        return {
+          currentValue: value,
+          startsWith: str
+        };
+      }
+    });
+  }
+  endsWith(str) {
+    return this.validation("endsWith", (value) => {
+      if (!value.endsWith(str)) {
+        return {
+          currentValue: value,
+          endsWith: str
+        };
+      }
+    });
+  }
+  regex(regex) {
+    return this.validation("regex", (value) => {
+      if (!regex.test(value)) {
+        return {
+          currentValue: value,
+          regex
+        };
+      }
+    });
+  }
+  email() {
+    const regex = /^(?:(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~.-]+)*)|(?:"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f])*"))@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$|(?:\[(?:\d{1,3}\.){3}\d{1,3}\])$/;
+    return this.validation("email", (value) => {
+      if (!regex.test(value)) {
+        return {
+          currentEmail: value
+        };
+      }
+    });
+  }
+  toJsonSchema() {
+    const schema = { type: "string" };
+    if (this._description) {
+      schema.description = this._description;
+    }
+    return schema;
+  }
+  url() {
+    const regex = /^(https?):\/\/(?![-0-9])(?!www\.[0-9])(?:[a-zA-Z0-9-]+(?::[a-zA-Z0-9-]+)?@)?(?:localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b|[a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.(?:[a-zA-Z]{2,}|[a-zA-Z]{2}\.[a-zA-Z]{2})(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$|^(https?):\/\/(localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b)(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$/;
+    return this.validation("url", (value) => {
+      if (!regex.test(value)) {
+        return {
+          currentUrl: value
+        };
+      }
+    });
+  }
+  ip() {
+    const IPv4regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+    const IPv6regex = /^(?:([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|:(:[0-9a-fA-F]{1,4}){1,7}|([0-9a-fA-F]{1,4}:){1,6}:([0-9a-fA-F]{1,4}:){1,6}[0-9a-fA-F]{1,4})$/;
+    return this.validation("ip", (value) => {
+      if (!(IPv4regex.test(value) || IPv6regex.test(value))) {
+        return {
+          currentIP: value
+        };
+      }
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    const validationInfo = {};
+    for (const validation of this.validations) {
+      switch (validation.name) {
+        case "minLength":
+          break;
+        case "maxLength":
+          break;
+        case "regex":
+          break;
+        case "email":
+          validationInfo.pattern = "email";
+          break;
+        case "url":
+          validationInfo.pattern = "url";
+          break;
+        case "ip":
+          validationInfo.pattern = "ip";
+          break;
+      }
+    }
+    return {
+      type: "string",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      },
+      validationInfo
+    };
+  }
+}
+function string() {
+  return new ArcString;
+}
+
+// elements/id.ts
+class ArcCustomId extends ArcBranded {
+  createFn;
+  constructor(name, createFn) {
+    super(string(), name);
+    this.createFn = createFn;
+  }
+  get(...args) {
+    return this.createFn(...args);
+  }
+}
+
+class ArcId extends ArcBranded {
+  generateFn;
+  constructor(name, generateFn) {
+    super(string(), name);
+    this.generateFn = generateFn;
+  }
+  generate() {
+    if (this.generateFn) {
+      return this.generateFn();
+    }
+    var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+    return timestamp + "xxxxxxxxxxxxxxxx".replace(/[x]/g, function() {
+      return (Math.random() * 16 | 0).toString(16);
+    }).toLowerCase();
+  }
+}
+function id(name, generateFn) {
+  return new ArcId(name, generateFn);
+}
+function customId(name, createFn) {
+  return new ArcCustomId(name, createFn);
+}
 // elements/number.ts
 var numberValidator = typeValidatorBuilder("number");
 
@@ -1001,6 +1185,26 @@ class ArcNumber extends ArcPrimitive {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    const validationInfo = {};
+    for (const validation of this.validations) {
+      switch (validation.name) {
+        case "min":
+          break;
+        case "max":
+          break;
+      }
+    }
+    return {
+      type: "number",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      },
+      validationInfo
+    };
+  }
 }
 function number() {
   return new ArcNumber;
@@ -1039,6 +1243,23 @@ class ArcOr {
       anyOf: this.elements.map((el) => el.toJsonSchema?.() ?? {})
     };
   }
+  getColumnData() {
+    return {
+      type: "object",
+      storeData: {
+        isNullable: false
+      },
+      validationInfo: {
+        unionTypes: this.elements.map((el) => {
+          try {
+            return el.getColumnData?.()?.type || "unknown";
+          } catch {
+            return "unknown";
+          }
+        })
+      }
+    };
+  }
   pickElement(value) {
     for (const element of this.elements) {
       if (this.isTypeOf(element, value))
@@ -1118,6 +1339,16 @@ class ArcRecord extends ArcAbstract {
     }
     return schema;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "record",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      }
+    };
+  }
 }
 function record(key, element) {
   return new ArcRecord(key, element);
@@ -1160,368 +1391,50 @@ class ArcStringEnum extends ArcAbstract {
   getEnumerators() {
     return this.values;
   }
+  getColumnData() {
+    const storeData = this.getStoreData();
+    return {
+      type: "stringEnum",
+      storeData: {
+        ...storeData,
+        isNullable: false
+      },
+      validationInfo: {
+        enumValues: this.values
+      }
+    };
+  }
 }
 function stringEnum(...values) {
   return new ArcStringEnum(values);
 }
-// utils/arcObjectToStoreSchema.ts
-function getSQLiteType(element2) {
-  if (element2 instanceof ArcDate) {
-    return "TEXT";
-  }
-  if (element2 instanceof ArcArray || element2 instanceof ArcObject) {
-    return "TEXT";
-  }
-  if (element2 instanceof ArcBoolean) {
-    return "INTEGER";
-  }
-  if (element2 instanceof ArcNumber) {
-    return "NUMBER";
-  }
-  return "TEXT";
-}
-function arcObjectToStoreSchema(tableName, schema) {
-  const columns = schema.entries().map(([name, element2]) => ({
-    name,
-    type: getSQLiteType(element2),
-    isOptional: element2 instanceof ArcOptional
-  }));
-  columns.unshift({
-    name: "_id",
-    type: "TEXT",
-    isOptional: false
-  }, {
-    name: "deleted",
-    type: "INTEGER",
-    isOptional: false,
-    default: 0
-  }, {
-    name: "lastUpdate",
-    type: "TEXT",
-    isOptional: false
-  });
-  return {
-    tables: [
-      {
-        name: tableName,
-        columns,
-        primaryKey: "_id"
-      }
-    ]
-  };
-}
-
-// context/query.ts
-class ArcQuery {
-  lastResult;
-  listeners = new Set;
-  subscribe(listener) {
-    this.listeners.add(listener);
+// command/command.ts
+class ArcCommand extends ArcContextElement {
+  name;
+  _description;
+  _params;
+  _results;
+  _elements;
+  _handler;
+  _isPublic = false;
+  constructor(name) {
+    super();
+    this.name = name;
   }
-  unsubscribe(listener) {
-    this.listeners.delete(listener);
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
   }
-  nextResult(result) {
-    this.lastResult = result;
-    this.listeners.forEach((listener) => listener(result));
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
   }
-}
-
-// context/serializable-query.ts
-class ArcSerializableQuery extends ArcQuery {
-  params;
-  static key;
-  constructor(params) {
-    super();
-    this.params = params;
-  }
-  serialize() {
-    return {
-      key: this.constructor.key,
-      params: this.params
-    };
-  }
-}
-
-// collection/queries/abstract-collection-query.ts
-class ArcCollectionQuery extends ArcSerializableQuery {
-  collection;
-  bindedChangeHandler = this.changeHandler.bind(this);
-  store;
-  constructor(collection, params) {
-    super(params);
-    this.collection = collection;
-  }
-  async run(dataStorage) {
-    const store = dataStorage.getStore(this.collection.name);
-    this.store = store;
-    const result = await this.fetch(store);
-    this.lastResult = result;
-    return result;
-  }
-  changeHandler(changes) {
-    let resultChanged = false;
-    for (const change of changes) {
-      const response = this.onChange(change);
-      if (response !== false) {
-        this.lastResult = response;
-        resultChanged = true;
-      }
-    }
-    if (resultChanged)
-      this.nextResult(this.lastResult);
-  }
-}
-
-// collection/queries/find.ts
-class QueryCollectionResult {
-  result;
-  constructor(result) {
-    this.result = result;
-  }
-  get(id3) {
-    return id3 ? this.result.find((r) => r._id === id3) : undefined;
-  }
-  map(callbackfn) {
-    return this.result.map(callbackfn);
-  }
-  toArray() {
-    return this.result;
-  }
-}
-
-class ArcFindQuery extends ArcCollectionQuery {
-  params;
-  constructor(collection, params) {
-    super(collection, params);
-    this.params = params;
-  }
-  async fetch(store) {
-    const results = await store.find(this.params, this.bindedChangeHandler);
-    return this.createResult(results);
-  }
-  checkItem(item) {
-    if (!this.params.where)
-      return true;
-    return Object.entries(this.params.where).every(([key, condition]) => {
-      const value = item[key];
-      if (typeof condition !== "object" || condition === null) {
-        return value === condition;
-      }
-      return Object.entries(condition).every(([operator, operatorValue]) => {
-        switch (operator) {
-          case "$eq":
-            return value === operatorValue;
-          case "$ne":
-            return value !== operatorValue;
-          case "$gt":
-            return typeof value === "number" && typeof operatorValue === "number" && value > operatorValue;
-          case "$gte":
-            return typeof value === "number" && typeof operatorValue === "number" && value >= operatorValue;
-          case "$lt":
-            return typeof value === "number" && typeof operatorValue === "number" && value < operatorValue;
-          case "$lte":
-            return typeof value === "number" && typeof operatorValue === "number" && value <= operatorValue;
-          case "$in":
-            return Array.isArray(operatorValue) && operatorValue.includes(value);
-          case "$nin":
-            return Array.isArray(operatorValue) && !operatorValue.includes(value);
-          case "$exists":
-            return typeof operatorValue === "boolean" ? operatorValue ? value !== undefined : value === undefined : true;
-          default:
-            return true;
-        }
-      });
-    });
-  }
-  onChange(change) {
-    const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult || [];
-    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
-    const isInLastResult = index !== -1;
-    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
-    if (isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.item));
-    else if (isInLastResult && (change.type === "delete" || !shouldBeInTheResult))
-      return this.createResult(lastResultAsArray.toSpliced(index, 1));
-    else if (!isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.concat(change.item));
-    return false;
-  }
-  createResult(result) {
-    return new QueryCollectionResult(result);
-  }
-}
-
-// collection/query-builders/find.ts
-class ArcFindQueryBuilder {
-  collection;
-  queryContext;
-  options;
-  constructor(collection, queryContext, options) {
-    this.collection = collection;
-    this.queryContext = queryContext;
-    this.options = options;
-  }
-  toQuery() {
-    return this.queryContext.cacheQuery(ArcFindQuery, [
-      this.collection,
-      this.options
-    ]);
-  }
-  run() {
-    return this.queryContext.runQuery(this.toQuery());
-  }
-}
-
-// collection/collection.ts
-class ArcCollection extends ArcContextElementWithStore {
-  name;
-  id;
-  schema;
-  options;
-  _restrictions;
-  constructor(name, id3, schema, options) {
-    super();
-    this.name = name;
-    this.id = id3;
-    this.schema = schema;
-    this.options = options;
-  }
-  storeSchema() {
-    return arcObjectToStoreSchema(this.name, this.schema);
-  }
-  restrictions(authContext) {
-    if (this._restrictions) {
-      return this._restrictions(authContext);
-    }
-    return {
-      read: false,
-      write: false,
-      modify: false,
-      delete: false
-    };
-  }
-  auth(restrictionsFn) {
-    const collection = new ArcCollection(this.name, this.id, this.schema, this.options);
-    collection._restrictions = restrictionsFn;
-    return collection;
-  }
-  serialize(data) {
-    return {
-      _id: this.id.serialize(data._id),
-      ...this.schema.serialize(data)
-    };
-  }
-  deserialize(data) {
-    return {
-      _id: this.id.deserialize(data._id),
-      ...this.schema.deserialize(data)
-    };
-  }
-  queryBuilder = (context) => {
-    return {
-      find: (options) => new ArcFindQueryBuilder(this, context, options || {})
-    };
-  };
-  commandContext = (dataStorage, publishEvent) => {
-    const store = dataStorage.getStore(this.name);
-    return {
-      add: async (data) => {
-        if (this.id instanceof ArcCustomId)
-          throw new Error("Collection with custom id not support 'add' method");
-        const id3 = this.id.generate();
-        const parsed = this.schema.parse(data);
-        const body = {
-          _id: id3,
-          lastUpdate: new Date().toISOString(),
-          ...parsed
-        };
-        await store.set(body);
-        await publishEvent({
-          type: "set",
-          to: body
-        });
-        return { id: id3 };
-      },
-      remove: async (id3) => {
-        await store.remove(id3);
-        return { success: true };
-      },
-      set: async (id3, data) => {
-        const parsed = this.schema.parse(data);
-        const body = {
-          _id: id3,
-          ...parsed
-        };
-        await store.set(body);
-        await publishEvent({
-          type: "set",
-          to: body
-        });
-        return { success: true };
-      },
-      find: async (options) => {
-        return store.find(options);
-      },
-      findOne: async (where) => {
-        const result = await store.find({
-          where,
-          limit: 1
-        });
-        return result[0];
-      },
-      modify: async (id3, data) => {
-        const deserialized = this.schema.serializePartial(data);
-        const { from, to } = await store.modify(id3, deserialized);
-        await publishEvent({
-          type: "modify",
-          changes: deserialized,
-          from,
-          to
-        });
-      },
-      edit: async (id3, editCallback) => {
-        const { from, to } = await store.mutate(id3, editCallback);
-        await publishEvent({
-          type: "mutate",
-          from,
-          to
-        });
-      }
-    };
-  };
-}
-function collection(name, id3, schema, options = {}) {
-  return new ArcCollection(name, id3, schema, options);
-}
-// command/command.ts
-class ArcCommand extends ArcContextElement {
-  name;
-  _description;
-  _params;
-  _results;
-  _elements;
-  _handler;
-  _isPublic = false;
-  constructor(name) {
-    super();
-    this.name = name;
-  }
-  use(elements) {
-    const clone = this.clone();
-    clone._elements = elements;
-    return clone;
-  }
-  description(description) {
-    const clone = this.clone();
-    clone._description = description;
-    return clone;
-  }
-  public() {
-    const clone = this.clone();
-    clone._isPublic = true;
-    return clone;
+  public() {
+    const clone = this.clone();
+    clone._isPublic = true;
+    return clone;
   }
   get isPublic() {
     return this._isPublic;
@@ -1590,15 +1503,19 @@ function command(name) {
 // context/context.ts
 class ArcContext {
   elements;
+  elementsSet = new Set;
   constructor(elements) {
     this.elements = elements;
+    this.elements.forEach((element2) => {
+      this.elementsSet.add(element2);
+    });
   }
   get(name) {
     return this.elements.find((element2) => element2.name === name);
   }
   getSyncListeners(eventType, authContext) {
     const listeners = [];
-    this.elements.forEach((element2) => {
+    this.elementsSet.forEach((element2) => {
       if (element2.observer) {
         const handlers = element2.observer(authContext);
         const config = handlers[eventType];
@@ -1611,7 +1528,7 @@ class ArcContext {
   }
   getAsyncListeners(eventType, authContext) {
     const listeners = [];
-    this.elements.forEach((element2) => {
+    this.elementsSet.forEach((element2) => {
       if (element2.observer) {
         const handlers = element2.observer(authContext);
         const config = handlers[eventType];
@@ -1682,6 +1599,28 @@ function contextMerge(...contexts) {
 }
 // context/event.ts
 var eventValidator = typeValidatorBuilder("object");
+var eventSchema = new ArcObject({
+  id: string().primaryKey(),
+  type: string(),
+  payload: any(),
+  createdAt: date()
+});
+var sharedEventDatabaseSchema = null;
+function getSharedEventDatabaseSchema() {
+  if (!sharedEventDatabaseSchema) {
+    sharedEventDatabaseSchema = {
+      tables: [{
+        name: "events",
+        schema: eventSchema,
+        options: {
+          softDelete: false,
+          versioning: true
+        }
+      }]
+    };
+  }
+  return sharedEventDatabaseSchema;
+}
 var eventStoreSchema = {
   tables: [
     {
@@ -1715,6 +1654,7 @@ class ArcEvent extends ArcContextElementWithStore {
   payload;
   _restrictions;
   storeSchema = () => eventStoreSchema;
+  databaseStoreSchema = () => getSharedEventDatabaseSchema();
   constructor(name, payload) {
     super();
     this.name = name;
@@ -1760,6 +1700,21 @@ class ArcEvent extends ArcContextElementWithStore {
 function event(name, payload) {
   return new ArcEvent(name, payload ? payload instanceof ArcObject ? payload : new ArcObject(payload) : undefined);
 }
+// context/query.ts
+class ArcQuery {
+  lastResult;
+  listeners = new Set;
+  subscribe(listener) {
+    this.listeners.add(listener);
+  }
+  unsubscribe(listener) {
+    this.listeners.delete(listener);
+  }
+  nextResult(result) {
+    this.lastResult = result;
+    this.listeners.forEach((listener) => listener(result));
+  }
+}
 // context/query-builder-context.ts
 class QueryBuilderContext {
   queryCache;
@@ -2228,107 +2183,729 @@ class MasterStoreState extends StoreState {
           item,
           id: change.id
         }
-      };
+      };
+    }
+    throw new Error("Unknown change type");
+  }
+  async applyChange(change) {
+    const transaction = await this.dataStorage.getReadWriteTransaction();
+    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
+    await transaction.commit();
+    this.notifyListeners([event3]);
+    return { from, to };
+  }
+  async applyChanges(changes) {
+    const transaction = await this.dataStorage.getReadWriteTransaction();
+    const events = [];
+    for (const change of changes) {
+      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change);
+      if (event3)
+        events.push(event3);
+    }
+    await transaction.commit();
+    if (events.length > 0) {
+      this.notifyListeners(events);
+    }
+  }
+  async find(options, listener) {
+    if (listener) {
+      this.listeners.set(listener, { callback: listener });
+    }
+    const transaction = await this.dataStorage.getReadTransaction();
+    const results = await transaction.find(this.storeName, options);
+    return results.map((item) => this.deserialize ? this.deserialize(item) : item);
+  }
+}
+
+// data-storage/data-storage-master.ts
+class MasterDataStorage extends DataStorage {
+  dbAdapter;
+  arcContext;
+  stores = new Map;
+  rtcAdapter;
+  reinitTablesExecuted = false;
+  constructor(dbAdapter, rtcAdapterFactory, arcContext) {
+    super();
+    this.dbAdapter = dbAdapter;
+    this.arcContext = arcContext;
+    this.rtcAdapter = rtcAdapterFactory(this);
+    this.executeReinitTablesOnReady();
+  }
+  async executeReinitTablesOnReady() {
+    try {
+      const adapter = await this.dbAdapter;
+      if (!this.reinitTablesExecuted) {
+        await adapter.executeReinitTables(this);
+        this.reinitTablesExecuted = true;
+      }
+    } catch (error) {
+      console.error("Failed to execute reinitTable functions:", error);
+    }
+  }
+  async getReadTransaction() {
+    return (await this.dbAdapter).readTransaction();
+  }
+  async getReadWriteTransaction() {
+    return (await this.dbAdapter).readWriteTransaction();
+  }
+  getStore(storeName) {
+    if (!this.stores.has(storeName)) {
+      this.stores.set(storeName, new MasterStoreState(storeName, this));
+    }
+    return this.stores.get(storeName);
+  }
+  async applyChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  }
+  applySerializedChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
+  }
+  async commitChanges(changes) {
+    await Promise.all([
+      this.applyChanges(changes),
+      this.rtcAdapter.commitChanges(changes)
+    ]);
+  }
+  fork() {
+    return new ForkedDataStorage(this);
+  }
+  async sync(progressCallback) {
+    await this.rtcAdapter.sync(progressCallback);
+  }
+}
+// database/schema-extraction.ts
+function extractDatabaseAgnosticSchema(arcObject, tableName) {
+  const columns = [];
+  for (const [fieldName, fieldSchema] of arcObject.entries()) {
+    const arcElement = fieldSchema;
+    if (typeof arcElement.getColumnData !== "function") {
+      throw new Error(`Element for field '${fieldName}' does not implement getColumnData() method. Element type: ${arcElement.constructor.name}`);
+    }
+    const columnInfo = arcElement.getColumnData();
+    const fullColumnInfo = {
+      name: fieldName,
+      ...columnInfo
+    };
+    columns.push(fullColumnInfo);
+  }
+  return {
+    tableName,
+    columns
+  };
+}
+
+// db/postgresAdapter.ts
+class PostgreSQLReadTransaction {
+  db;
+  tables;
+  adapter;
+  constructor(db, tables, adapter) {
+    this.db = db;
+    this.tables = tables;
+    this.adapter = adapter;
+  }
+  hasSoftDelete(tableName) {
+    if (this.adapter) {
+      return this.adapter.hasSoftDelete(tableName);
+    }
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "deleted");
+  }
+  deserializeValue(value, column) {
+    if (value === null || value === undefined)
+      return null;
+    switch (column.type.toLowerCase()) {
+      case "json":
+      case "jsonb":
+        if (typeof value === "string") {
+          try {
+            return JSON.parse(value);
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      case "text":
+        if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+          try {
+            const parsed = JSON.parse(value);
+            if (typeof parsed === "object" || Array.isArray(parsed)) {
+              return parsed;
+            }
+          } catch {}
+        }
+        return value;
+      case "datetime":
+      case "timestamp":
+        return new Date(value);
+      default:
+        return value;
+    }
+  }
+  deserializeRow(row, table) {
+    const result = {};
+    for (const column of table.columns) {
+      const value = row[column.name];
+      result[column.name] = this.deserializeValue(value, column);
+    }
+    return result;
+  }
+  getId(store, id3) {
+    return id3;
+  }
+  buildWhereClause(where, tableName) {
+    const conditions = [];
+    const params = [];
+    let paramIndex = 1;
+    if (tableName && this.hasSoftDelete(tableName)) {
+      conditions.push('"deleted" = $1');
+      params.push(false);
+      paramIndex = 2;
+    }
+    if (!where) {
+      return {
+        sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
+        params
+      };
+    }
+    Object.entries(where).forEach(([key, value]) => {
+      if (typeof value === "object" && value !== null) {
+        Object.entries(value).forEach(([operator, operand]) => {
+          switch (operator) {
+            case "$eq":
+            case "$ne":
+            case "$gt":
+            case "$gte":
+            case "$lt":
+            case "$lte":
+              conditions.push(`"${key}" ${this.getOperatorSymbol(operator)} $${paramIndex}`);
+              params.push(operand);
+              paramIndex++;
+              break;
+            case "$in":
+            case "$nin":
+              if (Array.isArray(operand)) {
+                const placeholders = operand.map(() => `$${paramIndex++}`).join(", ");
+                conditions.push(`"${key}" ${operator === "$in" ? "IN" : "NOT IN"} (${placeholders})`);
+                params.push(...operand);
+              }
+              break;
+            case "$exists":
+              if (typeof operand === "boolean") {
+                conditions.push(operand ? `"${key}" IS NOT NULL` : `"${key}" IS NULL`);
+              }
+              break;
+          }
+        });
+      } else {
+        conditions.push(`"${key}" = $${paramIndex}`);
+        params.push(value);
+        paramIndex++;
+      }
+    });
+    return {
+      sql: conditions.join(" AND "),
+      params
+    };
+  }
+  getOperatorSymbol(operator) {
+    const operators = {
+      $eq: "=",
+      $ne: "!=",
+      $gt: ">",
+      $gte: ">=",
+      $lt: "<",
+      $lte: "<="
+    };
+    return operators[operator] || "=";
+  }
+  buildOrderByClause(orderBy) {
+    if (!orderBy)
+      return "";
+    const orderClauses = Object.entries(orderBy).map(([key, direction]) => `"${key}" ${direction.toUpperCase()}`).join(", ");
+    return orderClauses ? `ORDER BY ${orderClauses}` : "";
+  }
+  async find(store, options) {
+    const { where, limit, offset, orderBy } = options || {};
+    const whereClause = this.buildWhereClause(where, store);
+    const orderByClause = this.buildOrderByClause(orderBy);
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    let query2 = `
+      SELECT * 
+      FROM "${store}" 
+      WHERE ${whereClause.sql}
+      ${orderByClause}
+    `;
+    let params = whereClause.params;
+    let paramIndex = params.length + 1;
+    if (limit) {
+      query2 += ` LIMIT $${paramIndex}`;
+      params.push(limit);
+      paramIndex++;
+    }
+    if (offset) {
+      query2 += ` OFFSET $${paramIndex}`;
+      params.push(offset);
+    }
+    const rows = await this.db.exec(query2, params);
+    return rows.map((row) => this.deserializeRow(row, table));
+  }
+}
+
+class PostgreSQLReadWriteTransaction extends PostgreSQLReadTransaction {
+  adapter;
+  queries = [];
+  constructor(db, tables, adapter) {
+    super(db, tables);
+    this.adapter = adapter;
+  }
+  async remove(store, id3) {
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    const query2 = `UPDATE "${store}" SET "deleted" = $1, "lastUpdate" = $2 WHERE "${table.primaryKey}" = $3`;
+    this.queries.push({
+      sql: query2,
+      params: [true, new Date().toISOString(), id3]
+    });
+  }
+  async set(store, item) {
+    const table = this.tables.get(store);
+    if (!table) {
+      throw new Error(`Store ${store} not found`);
+    }
+    const hasVersioning = this.adapter.hasVersioning(store);
+    if (hasVersioning) {
+      await this.setWithVersioning(store, item, table);
+    } else {
+      await this.setWithoutVersioning(store, item, table);
+    }
+  }
+  async setWithoutVersioning(store, item, table) {
+    const columnNames = table.columns.map((col) => col.name);
+    const values = table.columns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined) {
+        value = column.default;
+      }
+      return this.serializeValue(value, column);
+    });
+    const placeholders = columnNames.map((_, i) => `$${i + 1}`).join(", ");
+    const updateColumns = columnNames.filter((col) => col !== table.primaryKey).map((col) => `"${col}" = EXCLUDED."${col}"`).join(", ");
+    if (store === "events") {
+      const simpleInsertSql = `
+        INSERT INTO "${table.name}"
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
+        VALUES (${placeholders})
+      `;
+      this.queries.push({
+        sql: simpleInsertSql,
+        params: values
+      });
+    } else {
+      const sql = `
+        INSERT INTO "${table.name}"
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
+        VALUES (${placeholders})
+        ON CONFLICT ("${table.primaryKey}")
+        DO UPDATE SET ${updateColumns}
+      `;
+      this.queries.push({
+        sql,
+        params: values
+      });
+    }
+  }
+  async setWithVersioning(store, item, table) {
+    const regularColumns = table.columns.filter((col) => col.name !== "__version");
+    const columnNames = regularColumns.map((col) => col.name);
+    const values = regularColumns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined) {
+        value = column.default;
+      }
+      return this.serializeValue(value, column);
+    });
+    columnNames.push("__version");
+    const placeholders = regularColumns.map((_, i) => `$${i + 1}`).join(", ");
+    const updateColumns = regularColumns.filter((col) => col.name !== table.primaryKey).map((col) => `"${col.name}" = EXCLUDED."${col.name}"`).join(", ");
+    const sql = `
+      WITH next_version AS (
+        INSERT INTO __arc_version_counters (table_name, last_version) 
+        VALUES ($${values.length + 1}, 1)
+        ON CONFLICT(table_name) 
+        DO UPDATE SET last_version = __arc_version_counters.last_version + 1
+        RETURNING last_version
+      ),
+      upsert AS (
+        INSERT INTO "${table.name}"
+        (${columnNames.map((c) => `"${c}"`).join(", ")})
+        VALUES (${placeholders}, (SELECT last_version FROM next_version))
+        ON CONFLICT ("${table.primaryKey}")
+        DO UPDATE SET ${updateColumns}${updateColumns ? ", " : ""}"__version" = (SELECT last_version FROM next_version)
+        RETURNING *
+      )
+      SELECT * FROM upsert
+    `;
+    this.queries.push({
+      sql,
+      params: [...values, store]
+    });
+  }
+  async commit() {
+    if (this.queries.length === 0) {
+      return Promise.resolve();
+    }
+    try {
+      await this.db.execBatch(this.queries);
+      this.queries = [];
+    } catch (error) {
+      this.queries = [];
+      throw error;
+    }
+  }
+  serializeValue(value, column) {
+    if (value === null || value === undefined)
+      return null;
+    switch (column.type.toLowerCase()) {
+      case "timestamp":
+      case "datetime":
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (typeof value === "number") {
+          const date3 = value > 10000000000 ? new Date(value) : new Date(value * 1000);
+          return date3.toISOString();
+        }
+        if (typeof value === "string") {
+          const date3 = new Date(value);
+          if (!isNaN(date3.getTime())) {
+            return date3.toISOString();
+          }
+        }
+        return value;
+      case "json":
+      case "jsonb":
+        return JSON.stringify(value);
+      default:
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (Array.isArray(value) || typeof value === "object") {
+          return JSON.stringify(value);
+        }
+        return value;
     }
-    throw new Error("Unknown change type");
   }
-  async applyChange(change) {
-    const transaction = await this.dataStorage.getReadWriteTransaction();
-    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
-    await transaction.commit();
-    this.notifyListeners([event3]);
-    return { from, to };
+}
+
+class PostgreSQLAdapter {
+  db;
+  context;
+  tables = new Map;
+  tableSchemas = new Map;
+  pendingReinitTables = [];
+  mapType(arcType, storeData) {
+    if (storeData?.databaseType?.postgresql) {
+      return storeData.databaseType.postgresql;
+    }
+    switch (arcType) {
+      case "string":
+      case "stringEnum":
+        return "TEXT";
+      case "id":
+      case "customId":
+        return storeData?.databaseType?.postgresql || "TEXT";
+      case "number":
+        return storeData?.isAutoIncrement ? "SERIAL" : "INTEGER";
+      case "boolean":
+        return "BOOLEAN";
+      case "date":
+        return "TIMESTAMP";
+      case "object":
+      case "array":
+      case "record":
+        return "JSONB";
+      case "blob":
+        return "BYTEA";
+      default:
+        return "TEXT";
+    }
   }
-  async applyChanges(changes) {
-    const transaction = await this.dataStorage.getReadWriteTransaction();
-    const events = [];
-    for (const change of changes) {
-      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change);
-      if (event3)
-        events.push(event3);
+  buildConstraints(storeData) {
+    const constraints = [];
+    if (storeData?.isPrimaryKey) {
+      constraints.push("PRIMARY KEY");
     }
-    await transaction.commit();
-    if (events.length > 0) {
-      this.notifyListeners(events);
+    if (storeData?.isUnique) {
+      constraints.push("UNIQUE");
+    }
+    if (storeData?.foreignKey) {
+      const { table, column, onDelete, onUpdate } = storeData.foreignKey;
+      let fkConstraint = `REFERENCES ${table}(${column})`;
+      if (onDelete)
+        fkConstraint += ` ON DELETE ${onDelete}`;
+      if (onUpdate)
+        fkConstraint += ` ON UPDATE ${onUpdate}`;
+      constraints.push(fkConstraint);
     }
+    return constraints;
   }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
+  generateColumnSQL(columnInfo) {
+    const type = this.mapType(columnInfo.type, columnInfo.storeData);
+    const constraints = [];
+    if (!columnInfo.storeData?.isNullable) {
+      constraints.push("NOT NULL");
     }
-    const transaction = await this.dataStorage.getReadTransaction();
-    const results = await transaction.find(this.storeName, options);
-    return results.map((item) => this.deserialize ? this.deserialize(item) : item);
+    constraints.push(...this.buildConstraints(columnInfo.storeData));
+    if (columnInfo.defaultValue !== undefined) {
+      if (type === "UUID" && columnInfo.defaultValue === "auto") {
+        constraints.push("DEFAULT gen_random_uuid()");
+      } else if (typeof columnInfo.defaultValue === "string") {
+        constraints.push(`DEFAULT '${columnInfo.defaultValue}'`);
+      } else {
+        constraints.push(`DEFAULT ${columnInfo.defaultValue}`);
+      }
+    }
+    return `"${columnInfo.name}" ${type} ${constraints.join(" ")}`.trim();
+  }
+  generateCreateTableSQL(tableName, columns) {
+    const columnDefinitions = columns.map((col) => this.generateColumnSQL(col));
+    const indexes = columns.filter((col) => col.storeData?.hasIndex && !col.storeData?.isPrimaryKey).map((col) => `CREATE INDEX IF NOT EXISTS idx_${tableName}_${col.name} ON "${tableName}"("${col.name}");`);
+    let sql = `CREATE TABLE IF NOT EXISTS "${tableName}" (
+  ${columnDefinitions.join(`,
+  `)}
+)`;
+    if (indexes.length > 0) {
+      sql += `;
+` + indexes.join(`
+`);
+    }
+    return sql;
   }
-}
-
-// data-storage/data-storage-master.ts
-class MasterDataStorage extends DataStorage {
-  dbAdapter;
-  arcContext;
-  stores = new Map;
-  rtcAdapter;
-  constructor(dbAdapter, rtcAdapterFactory, arcContext) {
-    super();
-    this.dbAdapter = dbAdapter;
-    this.arcContext = arcContext;
-    this.rtcAdapter = rtcAdapterFactory(this);
+  constructor(db, context3) {
+    this.db = db;
+    this.context = context3;
+    this.context.elements.forEach((element3) => {
+      if ("databaseStoreSchema" in element3 && typeof element3.databaseStoreSchema === "function") {
+        const databaseSchema = element3.databaseStoreSchema();
+        databaseSchema.tables.forEach((dbTable) => {
+          const agnosticSchema = extractDatabaseAgnosticSchema(dbTable.schema, dbTable.name);
+          const columns = agnosticSchema.columns.map((columnInfo) => ({
+            name: columnInfo.name,
+            type: this.mapType(columnInfo.type, columnInfo.storeData),
+            constraints: this.buildConstraints(columnInfo.storeData),
+            isNullable: columnInfo.storeData?.isNullable || false,
+            defaultValue: columnInfo.defaultValue,
+            isPrimaryKey: columnInfo.storeData?.isPrimaryKey || false,
+            isAutoIncrement: columnInfo.storeData?.isAutoIncrement || false,
+            isUnique: columnInfo.storeData?.isUnique || false,
+            hasIndex: columnInfo.storeData?.hasIndex || false,
+            foreignKey: columnInfo.storeData?.foreignKey
+          }));
+          this.tableSchemas.set(dbTable.name, columns);
+          const legacyTable = {
+            name: dbTable.name,
+            primaryKey: columns.find((col) => col.isPrimaryKey)?.name || "_id",
+            columns: columns.map((col) => ({
+              name: col.name,
+              type: col.type,
+              isOptional: col.isNullable,
+              default: col.defaultValue
+            }))
+          };
+          this.tables.set(dbTable.name, legacyTable);
+        });
+      }
+    });
   }
-  async getReadTransaction() {
-    return (await this.dbAdapter).readTransaction();
+  async initialize() {
+    await this.createVersionCounterTable();
+    await this.createTableVersionsTable();
+    const processedSchemas = new Set;
+    const processedTables = new Set;
+    for (const element3 of this.context.elements) {
+      if ("databaseStoreSchema" in element3 && typeof element3.databaseStoreSchema === "function") {
+        const databaseSchema = element3.databaseStoreSchema();
+        if (processedSchemas.has(databaseSchema)) {
+          continue;
+        }
+        processedSchemas.add(databaseSchema);
+        for (const dbTable of databaseSchema.tables) {
+          const tableKey = dbTable.version ? `${dbTable.name}_v${dbTable.version}` : dbTable.name;
+          if (!processedTables.has(tableKey)) {
+            const agnosticSchema = extractDatabaseAgnosticSchema(dbTable.schema, dbTable.name);
+            let allColumns = [...agnosticSchema.columns];
+            if (dbTable.options?.versioning) {
+              allColumns.push({
+                name: "__version",
+                type: "number",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: 1
+              });
+            }
+            if (dbTable.options?.softDelete) {
+              allColumns.push({
+                name: "deleted",
+                type: "boolean",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: false
+              });
+            }
+            const physicalTableName = this.getPhysicalTableName(dbTable.name, dbTable.version);
+            if (dbTable.version && await this.checkVersionedTableExists(dbTable.name, dbTable.version)) {
+              console.log(`Versioned table ${physicalTableName} already exists, skipping creation`);
+            } else {
+              await this.createTableIfNotExistsNew(physicalTableName, allColumns);
+              if (dbTable.version) {
+                await this.registerTableVersion(dbTable.name, dbTable.version, physicalTableName);
+                if (databaseSchema.reinitTable) {
+                  this.pendingReinitTables.push({
+                    tableName: physicalTableName,
+                    reinitFn: databaseSchema.reinitTable
+                  });
+                }
+              }
+            }
+            const legacyTable = {
+              name: physicalTableName,
+              primaryKey: allColumns.find((col) => col.storeData?.isPrimaryKey)?.name || "_id",
+              columns: allColumns.map((col) => ({
+                name: col.name,
+                type: this.mapType(col.type, col.storeData),
+                isOptional: col.storeData?.isNullable || false,
+                default: col.defaultValue
+              }))
+            };
+            this.tables.set(dbTable.name, legacyTable);
+            processedTables.add(tableKey);
+          }
+        }
+      }
+    }
   }
-  async getReadWriteTransaction() {
-    return (await this.dbAdapter).readWriteTransaction();
+  async createTableIfNotExistsNew(tableName, columns) {
+    const createTableSQL = this.generateCreateTableSQL(tableName, columns);
+    await this.db.exec(createTableSQL);
   }
-  getStore(storeName) {
-    if (!this.stores.has(storeName)) {
-      this.stores.set(storeName, new MasterStoreState(storeName, this));
-    }
-    return this.stores.get(storeName);
+  async createVersionCounterTable() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS __arc_version_counters (
+        table_name TEXT PRIMARY KEY,
+        last_version BIGINT NOT NULL DEFAULT 0
+      )
+    `;
+    await this.db.exec(sql);
   }
-  async applyChanges(changes) {
-    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  async createTableVersionsTable() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS __arc_table_versions (
+        table_name TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        physical_table_name TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        is_active BOOLEAN DEFAULT FALSE,
+        PRIMARY KEY (table_name, version)
+      )
+    `;
+    await this.db.exec(sql);
   }
-  applySerializedChanges(changes) {
-    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
+  getPhysicalTableName(logicalName, version) {
+    return version ? `${logicalName}_v${version}` : logicalName;
   }
-  async commitChanges(changes) {
-    await Promise.all([
-      this.applyChanges(changes),
-      this.rtcAdapter.commitChanges(changes)
-    ]);
+  async checkVersionedTableExists(logicalName, version) {
+    const result = await this.db.exec("SELECT COUNT(*) as count FROM __arc_table_versions WHERE table_name = $1 AND version = $2", [logicalName, version]);
+    return result[0]?.count > 0;
   }
-  fork() {
-    return new ForkedDataStorage(this);
+  async registerTableVersion(logicalName, version, physicalName) {
+    await this.db.exec("INSERT INTO __arc_table_versions (table_name, version, physical_table_name, is_active) VALUES ($1, $2, $3, $4)", [logicalName, version, physicalName, true]);
   }
-  async sync(progressCallback) {
-    await this.rtcAdapter.sync(progressCallback);
+  hasVersioning(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "__version");
+  }
+  hasSoftDelete(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "deleted");
+  }
+  async executeReinitTables(dataStorage) {
+    for (const { tableName, reinitFn } of this.pendingReinitTables) {
+      try {
+        await reinitFn(tableName, dataStorage);
+        console.log(`Successfully reinitialized table: ${tableName}`);
+      } catch (error) {
+        console.error(`Failed to reinitialize table ${tableName}:`, error);
+        throw error;
+      }
+    }
+    this.pendingReinitTables = [];
+  }
+  readWriteTransaction(stores) {
+    return new PostgreSQLReadWriteTransaction(this.db, this.tables, this);
+  }
+  readTransaction(stores) {
+    return new PostgreSQLReadTransaction(this.db, this.tables, this);
   }
 }
+var createPostgreSQLAdapterFactory = (db) => {
+  return async (context3) => {
+    const adapter = new PostgreSQLAdapter(db, context3);
+    await adapter.initialize();
+    return adapter;
+  };
+};
 // db/sqliteAdapter.ts
 class SQLiteReadTransaction {
   db;
   tables;
-  constructor(db, tables) {
+  adapter;
+  constructor(db, tables, adapter) {
     this.db = db;
     this.tables = tables;
+    this.adapter = adapter;
+  }
+  hasSoftDelete(tableName) {
+    if (this.adapter) {
+      return this.adapter.hasSoftDelete(tableName);
+    }
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "deleted");
   }
   deserializeValue(value, column) {
     if (value === null || value === undefined)
       return null;
     switch (column.type.toLowerCase()) {
       case "json":
-      case "text": {
-        try {
-          const parsed = JSON.parse(value);
-          if (typeof parsed === "object" || Array.isArray(parsed)) {
-            return parsed;
+        if (typeof value === "string") {
+          try {
+            return JSON.parse(value);
+          } catch {
+            return value;
           }
-          return value;
-        } catch {
-          return value;
         }
-      }
+        return value;
+      case "text":
+        if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+          try {
+            const parsed = JSON.parse(value);
+            if (typeof parsed === "object" || Array.isArray(parsed)) {
+              return parsed;
+            }
+          } catch {}
+        }
+        return value;
       case "datetime":
       case "timestamp":
         return new Date(value);
@@ -2347,12 +2924,18 @@ class SQLiteReadTransaction {
   getId(store, id3) {
     return id3;
   }
-  buildWhereClause(where) {
+  buildWhereClause(where, tableName) {
+    const conditions = [];
+    const params = [];
+    if (tableName && this.hasSoftDelete(tableName)) {
+      conditions.push("deleted = 0");
+    }
     if (!where) {
-      return { sql: "deleted != 1", params: [] };
+      return {
+        sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
+        params
+      };
     }
-    const conditions = ["deleted != 1"];
-    const params = [];
     Object.entries(where).forEach(([key, value]) => {
       if (typeof value === "object" && value !== null) {
         Object.entries(value).forEach(([operator, operand]) => {
@@ -2409,7 +2992,7 @@ class SQLiteReadTransaction {
   }
   async find(store, options) {
     const { where, limit, offset, orderBy } = options || {};
-    const whereClause = this.buildWhereClause(where);
+    const whereClause = this.buildWhereClause(where, store);
     const orderByClause = this.buildOrderByClause(orderBy);
     const table = this.tables.get(store);
     if (!table) {
@@ -2429,6 +3012,11 @@ class SQLiteReadTransaction {
 }
 
 class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
+  adapter;
+  constructor(db, tables, adapter) {
+    super(db, tables, adapter);
+    this.adapter = adapter;
+  }
   async remove(store, id3) {
     const table = this.tables.get(store);
     if (!table) {
@@ -2442,7 +3030,14 @@ class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
     if (!table) {
       throw new Error(`Store ${store} not found`);
     }
-    const now = new Date().toISOString();
+    const hasVersioning = this.adapter.hasVersioning(store);
+    if (hasVersioning) {
+      await this.setWithVersioning(store, item, table);
+    } else {
+      await this.setWithoutVersioning(store, item, table);
+    }
+  }
+  async setWithoutVersioning(store, item, table) {
     const columnNames = table.columns.map((col) => col.name);
     const values = table.columns.map((column) => {
       let value = item[column.name];
@@ -2459,6 +3054,32 @@ class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
       `;
     await this.db.exec(sql, values);
   }
+  async setWithVersioning(store, item, table) {
+    const regularColumns = table.columns.filter((col) => col.name !== "__version");
+    const columnNames = regularColumns.map((col) => col.name);
+    const values = regularColumns.map((column) => {
+      let value = item[column.name];
+      if (value === undefined && column.default !== undefined) {
+        value = column.default;
+      }
+      return this.serializeValue(value, column);
+    });
+    columnNames.push("__version");
+    const placeholders = regularColumns.map(() => "?").join(", ");
+    const sql = `
+      WITH next_version AS (
+        INSERT INTO __arc_version_counters (table_name, last_version) 
+        VALUES (?, 1)
+        ON CONFLICT(table_name) 
+        DO UPDATE SET last_version = last_version + 1
+        RETURNING last_version
+      )
+      INSERT OR REPLACE INTO ${table.name}
+      (${columnNames.map((c) => `"${c}"`).join(", ")})
+      VALUES (${placeholders}, (SELECT last_version FROM next_version))
+    `;
+    await this.db.exec(sql, [...values, store]);
+  }
   async commit() {
     return Promise.resolve();
   }
@@ -2466,6 +3087,22 @@ class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
     if (value === null || value === undefined)
       return null;
     switch (column.type.toLowerCase()) {
+      case "timestamp":
+      case "datetime":
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (typeof value === "number") {
+          const date3 = value > 10000000000 ? new Date(value) : new Date(value * 1000);
+          return date3.toISOString();
+        }
+        if (typeof value === "string") {
+          const date3 = new Date(value);
+          if (!isNaN(date3.getTime())) {
+            return date3.toISOString();
+          }
+        }
+        return value;
       case "json":
         return JSON.stringify(value);
       default:
@@ -2484,58 +3121,238 @@ class SQLiteAdapter {
   db;
   context;
   tables = new Map;
+  tableSchemas = new Map;
+  pendingReinitTables = [];
+  mapType(arcType, storeData) {
+    if (storeData?.databaseType?.sqlite) {
+      return storeData.databaseType.sqlite;
+    }
+    switch (arcType) {
+      case "string":
+      case "id":
+      case "customId":
+      case "stringEnum":
+        return "TEXT";
+      case "number":
+        return "INTEGER";
+      case "boolean":
+        return "INTEGER";
+      case "date":
+        return "TIMESTAMP";
+      case "object":
+      case "array":
+      case "record":
+        return "JSON";
+      case "blob":
+        return "BLOB";
+      default:
+        return "TEXT";
+    }
+  }
+  buildConstraints(storeData) {
+    const constraints = [];
+    if (storeData?.isPrimaryKey) {
+      constraints.push("PRIMARY KEY");
+    }
+    if (storeData?.isAutoIncrement) {
+      constraints.push("AUTOINCREMENT");
+    }
+    if (storeData?.isUnique) {
+      constraints.push("UNIQUE");
+    }
+    if (storeData?.foreignKey) {
+      const { table, column, onDelete, onUpdate } = storeData.foreignKey;
+      let fkConstraint = `REFERENCES ${table}(${column})`;
+      if (onDelete)
+        fkConstraint += ` ON DELETE ${onDelete}`;
+      if (onUpdate)
+        fkConstraint += ` ON UPDATE ${onUpdate}`;
+      constraints.push(fkConstraint);
+    }
+    return constraints;
+  }
+  generateColumnSQL(columnInfo) {
+    const type = this.mapType(columnInfo.type, columnInfo.storeData);
+    const constraints = [];
+    if (!columnInfo.storeData?.isNullable) {
+      constraints.push("NOT NULL");
+    }
+    constraints.push(...this.buildConstraints(columnInfo.storeData));
+    if (columnInfo.defaultValue !== undefined) {
+      constraints.push(`DEFAULT ${JSON.stringify(columnInfo.defaultValue)}`);
+    }
+    return `"${columnInfo.name}" ${type} ${constraints.join(" ")}`.trim();
+  }
+  generateCreateTableSQL(tableName, columns) {
+    const columnDefinitions = columns.map((col) => this.generateColumnSQL(col));
+    const indexes = columns.filter((col) => col.storeData?.hasIndex && !col.storeData?.isPrimaryKey).map((col) => `CREATE INDEX IF NOT EXISTS idx_${tableName}_${col.name} ON ${tableName}(${col.name});`);
+    let sql = `CREATE TABLE IF NOT EXISTS ${tableName} (
+  ${columnDefinitions.join(`,
+  `)}
+)`;
+    if (indexes.length > 0) {
+      sql += `;
+` + indexes.join(`
+`);
+    }
+    return sql;
+  }
   constructor(db, context3) {
     this.db = db;
     this.context = context3;
     this.context.elements.forEach((element3) => {
-      if ("storeSchema" in element3 && typeof element3.storeSchema === "function") {
-        element3.storeSchema().tables.forEach((table) => {
-          this.tables.set(table.name, table);
+      if ("databaseStoreSchema" in element3 && typeof element3.databaseStoreSchema === "function") {
+        const databaseSchema = element3.databaseStoreSchema();
+        databaseSchema.tables.forEach((dbTable) => {
+          const agnosticSchema = extractDatabaseAgnosticSchema(dbTable.schema, dbTable.name);
+          const columns = agnosticSchema.columns.map((columnInfo) => ({
+            name: columnInfo.name,
+            type: this.mapType(columnInfo.type, columnInfo.storeData),
+            constraints: this.buildConstraints(columnInfo.storeData),
+            isNullable: columnInfo.storeData?.isNullable || false,
+            defaultValue: columnInfo.defaultValue,
+            isPrimaryKey: columnInfo.storeData?.isPrimaryKey || false,
+            isAutoIncrement: columnInfo.storeData?.isAutoIncrement || false,
+            isUnique: columnInfo.storeData?.isUnique || false,
+            hasIndex: columnInfo.storeData?.hasIndex || false,
+            foreignKey: columnInfo.storeData?.foreignKey
+          }));
+          this.tableSchemas.set(dbTable.name, columns);
+          const physicalTableName = this.getPhysicalTableName(dbTable.name, dbTable.version);
+          const legacyTable = {
+            name: physicalTableName,
+            primaryKey: columns.find((col) => col.isPrimaryKey)?.name || "_id",
+            columns: columns.map((col) => ({
+              name: col.name,
+              type: col.type,
+              isOptional: col.isNullable,
+              default: col.defaultValue
+            }))
+          };
+          this.tables.set(dbTable.name, legacyTable);
         });
       }
     });
   }
   async initialize() {
-    const stores = new Set;
+    await this.createVersionCounterTable();
+    await this.createTableVersionsTable();
+    const processedSchemas = new Set;
+    const processedTables = new Set;
     for (const element3 of this.context.elements) {
-      if ("storeSchema" in element3 && typeof element3.storeSchema === "function") {
-        const schema = element3.storeSchema();
-        stores.add(schema);
-      }
-    }
-    for (const schema of stores) {
-      for (const table of schema.tables) {
-        await this.createTableIfNotExists(table);
+      if ("databaseStoreSchema" in element3 && typeof element3.databaseStoreSchema === "function") {
+        const databaseSchema = element3.databaseStoreSchema();
+        if (processedSchemas.has(databaseSchema)) {
+          continue;
+        }
+        processedSchemas.add(databaseSchema);
+        for (const dbTable of databaseSchema.tables) {
+          const tableKey = dbTable.version ? `${dbTable.name}_v${dbTable.version}` : dbTable.name;
+          if (!processedTables.has(tableKey)) {
+            const agnosticSchema = extractDatabaseAgnosticSchema(dbTable.schema, dbTable.name);
+            let allColumns = [...agnosticSchema.columns];
+            if (dbTable.options?.versioning) {
+              allColumns.push({
+                name: "__version",
+                type: "number",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: 1
+              });
+            }
+            if (dbTable.options?.softDelete) {
+              allColumns.push({
+                name: "deleted",
+                type: "boolean",
+                storeData: { isNullable: false, hasIndex: true },
+                defaultValue: false
+              });
+            }
+            const physicalTableName = this.getPhysicalTableName(dbTable.name, dbTable.version);
+            if (dbTable.version && await this.checkVersionedTableExists(dbTable.name, dbTable.version)) {
+              console.log(`Versioned table ${physicalTableName} already exists, skipping creation`);
+            } else {
+              await this.createTableIfNotExistsNew(physicalTableName, allColumns);
+              if (dbTable.version) {
+                await this.registerTableVersion(dbTable.name, dbTable.version, physicalTableName);
+                if (databaseSchema.reinitTable) {
+                  this.pendingReinitTables.push({
+                    tableName: physicalTableName,
+                    reinitFn: databaseSchema.reinitTable
+                  });
+                }
+              }
+            }
+            processedTables.add(tableKey);
+          }
+        }
       }
     }
   }
-  async createTableIfNotExists(table) {
-    const columns = table.columns.map((column) => {
-      const constraints = [];
-      if (!column.isOptional) {
-        constraints.push("NOT NULL");
-      }
-      if (column.default !== undefined) {
-        constraints.push(`DEFAULT ${JSON.stringify(column.default)}`);
-      }
-      if (column.name === table.primaryKey) {
-        constraints.push("PRIMARY KEY");
-      }
-      return `"${column.name}" ${column.type} ${constraints.join(" ")}`.trim();
-    });
-    const createTableSQL = `
-      CREATE TABLE IF NOT EXISTS ${table.name} (
-        ${columns.join(`,
-        `)}
+  async createTableIfNotExistsNew(tableName, columns) {
+    const createTableSQL = this.generateCreateTableSQL(tableName, columns);
+    await this.db.exec(createTableSQL);
+  }
+  async createVersionCounterTable() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS __arc_version_counters (
+        table_name TEXT PRIMARY KEY,
+        last_version INTEGER NOT NULL DEFAULT 0
       )
     `;
-    await this.db.exec(createTableSQL);
+    await this.db.exec(sql);
+  }
+  async createTableVersionsTable() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS __arc_table_versions (
+        table_name TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        physical_table_name TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        is_active INTEGER DEFAULT 0,
+        PRIMARY KEY (table_name, version)
+      )
+    `;
+    await this.db.exec(sql);
+  }
+  getPhysicalTableName(logicalName, version) {
+    return version ? `${logicalName}_v${version}` : logicalName;
+  }
+  async checkVersionedTableExists(logicalName, version) {
+    const result = await this.db.exec("SELECT COUNT(*) as count FROM __arc_table_versions WHERE table_name = ? AND version = ?", [logicalName, version]);
+    return result[0]?.count > 0;
+  }
+  async registerTableVersion(logicalName, version, physicalName) {
+    await this.db.exec("INSERT INTO __arc_table_versions (table_name, version, physical_table_name, is_active) VALUES (?, ?, ?, ?)", [logicalName, version, physicalName, 1]);
+  }
+  hasVersioning(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "__version");
+  }
+  hasSoftDelete(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table)
+      return false;
+    return table.columns.some((col) => col.name === "deleted");
+  }
+  async executeReinitTables(dataStorage) {
+    for (const { tableName, reinitFn } of this.pendingReinitTables) {
+      try {
+        await reinitFn(tableName, dataStorage);
+        console.log(`Successfully reinitialized table: ${tableName}`);
+      } catch (error) {
+        console.error(`Failed to reinitialize table ${tableName}:`, error);
+        throw error;
+      }
+    }
+    this.pendingReinitTables = [];
   }
   readWriteTransaction(stores) {
-    return new SQLiteReadWriteTransaction(this.db, this.tables);
+    return new SQLiteReadWriteTransaction(this.db, this.tables, this);
   }
   readTransaction(stores) {
-    return new SQLiteReadTransaction(this.db, this.tables);
+    return new SQLiteReadTransaction(this.db, this.tables, this);
   }
 }
 var createSQLiteAdapterFactory = (db) => {
@@ -2599,17 +3416,17 @@ class ArcListener extends ArcContextElement {
                 return (e) => {
                   const element4 = this._elements.find((element5) => element5.name === e.name);
                   if (!element4) {
-                    throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
+                    throw new Error(`Element "${String(e.name)}" not found in listener "${this.name}"`);
                   }
                   if (!element4.commandContext) {
-                    throw new Error(`Element "${String(name)}" does not have a command context`);
+                    throw new Error(`Element "${String(e.name)}" does not have a command context`);
                   }
                   return element4.commandContext(dataStorage, publishEvent, authContext);
                 };
               }
               const element3 = this._elements.find((element4) => element4.name === name);
               if (!element3) {
-                throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
+                throw new Error(`Element "${element3}" not found in listener "${this.name}"`);
               }
               if (!element3.commandContext) {
                 throw new Error(`Element "${String(name)}" does not have a command context`);
@@ -2673,14 +3490,14 @@ class EventPublisher {
   async runAsyncListeners() {
     const allAsyncTasks = this.asyncEvents.flatMap(({ event: event3, listeners, authContext }) => listeners.map(async (listener3) => {
       const listenerFork = this.dataStorage.fork();
+      const childPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
       const asyncPublishEvent = async (childEvent) => {
-        const childPublisher = new EventPublisher(this.context, listenerFork, authContext);
         await childPublisher.publishEvent(childEvent, listenerFork);
-        await childPublisher.runAsyncListeners();
       };
       try {
         await listener3(event3, listenerFork, asyncPublishEvent);
         await listenerFork.merge();
+        childPublisher.runAsyncListeners();
       } catch (error) {
         console.error("Async listener failed:", error);
       }
@@ -3154,6 +3971,22 @@ class RTCClient {
 var rtcClientFactory = (token) => (storage) => {
   return new RTCClient(storage, token);
 };
+// context/serializable-query.ts
+class ArcSerializableQuery extends ArcQuery {
+  params;
+  static key;
+  constructor(params) {
+    super();
+    this.params = params;
+  }
+  serialize() {
+    return {
+      key: this.constructor.key,
+      params: this.params
+    };
+  }
+}
+
 // view/queries/abstract-view-query.ts
 class ArcViewQuery extends ArcSerializableQuery {
   view;
@@ -3457,6 +4290,7 @@ class ArcView extends ArcContextElementWithStore {
   _elements;
   _handler;
   _isAsync = false;
+  _version;
   restrictions;
   constructor(name, id3, schema) {
     super();
@@ -3464,8 +4298,84 @@ class ArcView extends ArcContextElementWithStore {
     this.id = id3;
     this.schema = schema;
   }
-  storeSchema = () => {
-    return arcObjectToStoreSchema(this.name, this.schema);
+  databaseStoreSchema = () => {
+    const systemFields = {
+      _id: string().primaryKey()
+    };
+    const completeSchema = this.schema.merge(systemFields);
+    return {
+      tables: [
+        {
+          name: this.name,
+          schema: completeSchema,
+          version: this._version,
+          options: {
+            softDelete: true,
+            versioning: true
+          }
+        }
+      ],
+      reinitTable: async (tableName, dataStorage) => {
+        console.log(`Reinitializing view table: ${tableName} for view: ${this.name}`);
+        if (this._handler && this._elements) {
+          try {
+            const eventStore = dataStorage.getStore("events");
+            const viewStore = dataStorage.getStore(this.name);
+            const events = await eventStore.find({
+              where: {
+                type: {
+                  $in: this._elements.filter((element3) => element3 instanceof ArcEvent).map((element3) => element3.name)
+                }
+              }
+            });
+            console.log(`Found ${events.length} events to replay for view ${this.name}`);
+            const reinitContext = {
+              set: async (id3, data) => {
+                const parsed = this.schema.parse(data);
+                const body = {
+                  _id: id3,
+                  lastUpdate: new Date().toISOString(),
+                  ...parsed
+                };
+                await viewStore.set(body);
+              },
+              modify: async (id3, data) => {
+                await viewStore.modify(id3, {
+                  ...data,
+                  lastUpdate: new Date().toISOString()
+                });
+              },
+              remove: async (id3) => {
+                await viewStore.remove(id3);
+              },
+              find: async (options) => {
+                return viewStore.find(options);
+              },
+              findOne: async (where) => {
+                const result = await viewStore.find({ where, limit: 1 });
+                return result[0];
+              },
+              $auth: {}
+            };
+            for (const event3 of events) {
+              if (this._handler && this._handler[event3.type]) {
+                try {
+                  await this._handler[event3.type](reinitContext, event3);
+                } catch (error) {
+                  console.error(`Error processing event ${event3.type} for view ${this.name}:`, error);
+                }
+              }
+            }
+            console.log(`Successfully reinitialized view ${this.name} with ${events.length} events`);
+          } catch (error) {
+            console.error(`Failed to reinitialize view ${this.name}:`, error);
+            throw error;
+          }
+        } else {
+          console.log(`No handlers defined for view ${this.name}, skipping event replay`);
+        }
+      }
+    };
   };
   auth(restrictionsFn) {
     const clone = this.clone();
@@ -3487,6 +4397,11 @@ class ArcView extends ArcContextElementWithStore {
     clone._isAsync = true;
     return clone;
   }
+  version(version) {
+    const clone = this.clone();
+    clone._version = version;
+    return clone;
+  }
   handle(handler) {
     const clone = this.clone();
     clone._handler = handler;
@@ -3607,6 +4522,7 @@ class ArcView extends ArcContextElementWithStore {
     clone._elements = this._elements;
     clone._handler = this._handler;
     clone._isAsync = this._isAsync;
+    clone._version = this._version;
     clone.restrictions = this.restrictions;
     return clone;
   }
@@ -3634,14 +4550,13 @@ export {
   date,
   customId,
   createSQLiteAdapterFactory,
+  createPostgreSQLAdapterFactory,
   contextMerge,
   context,
   command,
-  collection,
   boolean,
   blob,
   array,
-  arcObjectToStoreSchema,
   any,
   StoreState,
   SQLiteAdapter,
@@ -3649,6 +4564,7 @@ export {
   QueryViewResult,
   QueryCache,
   QueryBuilderContext,
+  PostgreSQLAdapter,
   ModelBase,
   Model,
   MasterStoreState,
@@ -3681,8 +4597,6 @@ export {
   ArcContextElement,
   ArcContext,
   ArcCommand,
-  ArcCollectionQuery,
-  ArcCollection,
   ArcBranded,
   ArcBoolean,
   ArcBlob,