@arcote.tech/arc 0.1.8 → 0.1.10

package/dist/context/context.d.ts

@@ -23,6 +23,7 @@ export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends
 }> ? RemoveFalseAndResolvedPromiseFromArray<[Inner, ...Rest]> : [First, ...RemoveFalseAndResolvedPromiseFromArray<Rest>] : [];
 export declare class ArcContext<const E extends ArcContextElementAny[]> {
     readonly elements: E;
+    private elementsSet;
     constructor(elements: E);
     get<Element extends E[number]>(name: Element["name"]): Element;
     getSyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];

package/dist/context/element.d.ts

@@ -21,6 +21,7 @@ export type EventAuthorizationRestrictions = {
     read?: boolean | WhereCondition;
     write?: boolean | WhereCondition;
 };
+import type { ArcObject } from "../elements/object";
 export type StoreColumn = {
     name: string;
     type: string;
@@ -45,6 +46,25 @@ export type StoreSchema = {
     tables: StoreTable[];
     relations?: StoreRelation[];
 };
+/**
+ * New database-agnostic schema definition
+ */
+export type DatabaseStoreTable = {
+    name: string;
+    schema: ArcObject<any>;
+    version?: number;
+    options?: {
+        /** Include soft delete columns */
+        softDelete?: boolean;
+        /** Include per-table version tracking for data syncing */
+        versioning?: boolean;
+    };
+};
+export type DatabaseStoreSchema = {
+    tables: DatabaseStoreTable[];
+    relations?: StoreRelation[];
+    reinitTable?: (tableName: string, dataStorage: DataStorage) => Promise<void>;
+};
 export declare abstract class ArcContextElement<const Event, const Name extends string | undefined = undefined> {
     readonly $event: Event;
     readonly name?: Name;
@@ -54,7 +74,7 @@ export declare abstract class ArcContextElement<const Event, const Name extends
     observer?: (authContext: AuthContext) => Record<string, ListenerConfig>;
 }
 export declare abstract class ArcContextElementWithStore<const Event, const Name extends string | undefined = undefined> extends ArcContextElement<Event, Name> {
-    abstract storeSchema(): StoreSchema;
+    abstract databaseStoreSchema(): DatabaseStoreSchema;
 }
 export type ArcContextElementAny = ArcContextElement<any, any>;
 //# sourceMappingURL=element.d.ts.map

package/dist/context/event.d.ts

@@ -1,7 +1,7 @@
 import type { DataStorage } from "../data-storage";
 import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements/object";
 import type { $type } from "../utils";
-import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type EventAuthorizationRestrictions, type StoreSchema } from "./element";
+import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type EventAuthorizationRestrictions, type StoreSchema, type DatabaseStoreSchema } from "./element";
 export type EventMetadata = {
     createdAt: Date;
 };
@@ -10,6 +10,7 @@ export declare class ArcEvent<const Name extends string, const PayloadShape exte
     readonly payload: PayloadShape;
     private _restrictions?;
     storeSchema: () => StoreSchema;
+    databaseStoreSchema: () => DatabaseStoreSchema;
     constructor(name: Name, payload: PayloadShape);
     /**
      * Default restrictions for events - deny all operations except for system users

package/dist/context/query-builders.d.ts

@@ -13,4 +13,5 @@ export declare abstract class ArcQueryBuilder implements IArcQueryBuilder {
 }
 export type UnaryFunction<T, R> = (input: T) => R;
 export type QueryFactoryFunction<C extends ArcContextAny> = UnaryFunction<ReturnType<C["queryBuilder"]>, IArcQueryBuilder>;
+export type QueryBuilderFunctionResult<QueryBuilderFn extends QueryFactoryFunction<any>> = QueryBuilderFn extends QueryFactoryFunction<infer C> ? Promise<ReturnType<ReturnType<QueryBuilderFn>["toQuery"]>["lastResult"]> : never;
 //# sourceMappingURL=query-builders.d.ts.map

package/dist/data-storage/data-storage-master.d.ts

@@ -9,7 +9,9 @@ export declare class MasterDataStorage extends DataStorage {
     private arcContext;
     private stores;
     private rtcAdapter;
+    private reinitTablesExecuted;
     constructor(dbAdapter: Promise<DatabaseAdapter> | DatabaseAdapter, rtcAdapterFactory: RealTimeCommunicationAdapterFactory, arcContext: ArcContextAny);
+    private executeReinitTablesOnReady;
     getReadTransaction(): Promise<ReadTransaction>;
     getReadWriteTransaction(): Promise<ReadWriteTransaction>;
     getStore<Item extends {

package/dist/database/database-mappers.d.ts

@@ -0,0 +1,39 @@
+import type { DatabaseType, DatabaseTypeMapper, DatabaseFeatures, DatabaseStoreData, DatabaseColumnDefinition } from "./database-store";
+/**
+ * SQLite Type Mapper
+ */
+export declare class SQLiteTypeMapper implements DatabaseTypeMapper {
+    databaseType: DatabaseType;
+    features: DatabaseFeatures;
+    mapType(arcTypeName: string, storeData?: DatabaseStoreData): string;
+    mapConstraints(storeData: DatabaseStoreData): string[];
+    generateColumnDefinition(column: DatabaseColumnDefinition): string;
+    generateCreateTableSQL(tableName: string, columns: DatabaseColumnDefinition[]): string;
+}
+/**
+ * PostgreSQL Type Mapper
+ */
+export declare class PostgreSQLTypeMapper implements DatabaseTypeMapper {
+    databaseType: DatabaseType;
+    features: DatabaseFeatures;
+    mapType(arcTypeName: string, storeData?: DatabaseStoreData): string;
+    mapConstraints(storeData: DatabaseStoreData): string[];
+    generateColumnDefinition(column: DatabaseColumnDefinition): string;
+    generateCreateTableSQL(tableName: string, columns: DatabaseColumnDefinition[]): string;
+}
+/**
+ * MySQL Type Mapper
+ */
+export declare class MySQLTypeMapper implements DatabaseTypeMapper {
+    databaseType: DatabaseType;
+    features: DatabaseFeatures;
+    mapType(arcTypeName: string, storeData?: DatabaseStoreData): string;
+    mapConstraints(storeData: DatabaseStoreData): string[];
+    generateColumnDefinition(column: DatabaseColumnDefinition): string;
+    generateCreateTableSQL(tableName: string, columns: DatabaseColumnDefinition[]): string;
+}
+/**
+ * Database Type Mapper Factory
+ */
+export declare function createDatabaseTypeMapper(databaseType: DatabaseType): DatabaseTypeMapper;
+//# sourceMappingURL=database-mappers.d.ts.map

package/dist/database/database-store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Database-agnostic store data types and interfaces
+ */
+export type DatabaseType = "sqlite" | "postgresql" | "mysql";
+export interface DatabaseStoreData {
+    /** Mark this field as primary key */
+    isPrimaryKey?: boolean;
+    /** Mark this field as auto-increment */
+    isAutoIncrement?: boolean;
+    /** Mark this field as unique */
+    isUnique?: boolean;
+    /** Add index to this field */
+    hasIndex?: boolean;
+    /** Foreign key relationship */
+    foreignKey?: {
+        table: string;
+        column: string;
+        onDelete?: "CASCADE" | "SET NULL" | "RESTRICT";
+        onUpdate?: "CASCADE" | "SET NULL" | "RESTRICT";
+    };
+    /** Database-specific type overrides */
+    databaseType?: {
+        sqlite?: string;
+        postgresql?: string;
+        mysql?: string;
+    };
+    /** Database-specific column options */
+    columnOptions?: {
+        sqlite?: string[];
+        postgresql?: string[];
+        mysql?: string[];
+    };
+}
+/**
+ * Database-agnostic column information returned by ArcObject elements
+ */
+export interface DatabaseAgnosticColumnInfo {
+    /** ArcObject type name (string, number, boolean, etc.) */
+    type: string;
+    /** Database store configuration (primary key, unique, etc.) */
+    storeData?: DatabaseStoreData & {
+        /** Whether the field is nullable */
+        isNullable?: boolean;
+    };
+    /** Default value for the field */
+    defaultValue?: any;
+    /** Validation information that might affect database constraints */
+    validationInfo?: {
+        minLength?: number;
+        maxLength?: number;
+        min?: number;
+        max?: number;
+        enumValues?: string[];
+        pattern?: string;
+        [key: string]: any;
+    };
+}
+//# sourceMappingURL=database-store.d.ts.map

package/dist/database/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./database-store";
+export * from "./schema-extraction";
+//# sourceMappingURL=index.d.ts.map

package/dist/database/schema-extraction.d.ts

@@ -0,0 +1,12 @@
+import type { ArcObject } from "../elements/object";
+import type { DatabaseAgnosticColumnInfo } from "./database-store";
+/**
+ * Extract database-agnostic schema information from ArcObject
+ */
+export declare function extractDatabaseAgnosticSchema(arcObject: ArcObject<any>, tableName: string): {
+    tableName: string;
+    columns: (DatabaseAgnosticColumnInfo & {
+        name: string;
+    })[];
+};
+//# sourceMappingURL=schema-extraction.d.ts.map

package/dist/db/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./interface";
+export * from "./postgresAdapter";
 export * from "./sqliteAdapter";
 //# sourceMappingURL=index.d.ts.map

package/dist/db/interface.d.ts

@@ -11,6 +11,7 @@ export interface ReadWriteTransaction extends ReadTransaction {
 export interface DatabaseAdapter {
     readWriteTransaction(stores?: string[]): ReadWriteTransaction;
     readTransaction(stores?: string[]): ReadTransaction;
+    executeReinitTables(dataStorage: any): Promise<void>;
 }
 export type DBAdapterFactory = (context: ArcContextAny) => Promise<DatabaseAdapter>;
 //# sourceMappingURL=interface.d.ts.map

package/dist/db/postgresAdapter.d.ts

@@ -0,0 +1,90 @@
+import { type ArcContextAny } from "../context";
+import type { StoreColumn, StoreTable } from "../context/element";
+import type { FindOptions, WhereCondition } from "../data-storage/types";
+import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./interface";
+export interface PostgreSQLDatabase {
+    exec(sql: string, params?: any[]): Promise<any>;
+    execBatch(queries: Array<{
+        sql: string;
+        params?: any[];
+    }>): Promise<any>;
+}
+declare class PostgreSQLReadTransaction implements ReadTransaction {
+    protected db: PostgreSQLDatabase;
+    protected tables: Map<string, StoreTable>;
+    protected adapter?: PostgreSQLAdapter | undefined;
+    constructor(db: PostgreSQLDatabase, tables: Map<string, StoreTable>, adapter?: PostgreSQLAdapter | undefined);
+    protected hasSoftDelete(tableName: string): boolean;
+    protected deserializeValue(value: any, column: StoreColumn): any;
+    protected deserializeRow(row: any, table: StoreTable): any;
+    protected getId(store: string, id: any): any;
+    protected buildWhereClause(where?: WhereCondition, tableName?: string): {
+        sql: string;
+        params: any[];
+    };
+    protected getOperatorSymbol(operator: string): string;
+    protected buildOrderByClause(orderBy?: Record<string, "asc" | "desc">): string;
+    find<T>(store: string, options: FindOptions<T>): Promise<T[]>;
+}
+declare class PostgreSQLReadWriteTransaction extends PostgreSQLReadTransaction implements ReadWriteTransaction {
+    protected adapter: PostgreSQLAdapter;
+    private queries;
+    constructor(db: PostgreSQLDatabase, tables: Map<string, StoreTable>, adapter: PostgreSQLAdapter);
+    remove(store: string, id: any): Promise<void>;
+    set(store: string, item: any): Promise<void>;
+    private setWithoutVersioning;
+    private setWithVersioning;
+    commit(): Promise<void>;
+    private serializeValue;
+}
+export declare class PostgreSQLAdapter implements DatabaseAdapter {
+    private db;
+    private context;
+    private tables;
+    private tableSchemas;
+    private pendingReinitTables;
+    private mapType;
+    private buildConstraints;
+    private generateColumnSQL;
+    private generateCreateTableSQL;
+    constructor(db: PostgreSQLDatabase, context: ArcContextAny);
+    initialize(): Promise<void>;
+    private createTableIfNotExistsNew;
+    /**
+     * Create the version counter table for tracking per-table version sequences
+     */
+    private createVersionCounterTable;
+    /**
+     * Create the table versions tracking table for schema versioning
+     */
+    private createTableVersionsTable;
+    /**
+     * Generate physical table name with version suffix
+     */
+    private getPhysicalTableName;
+    /**
+     * Check if a versioned table exists
+     */
+    private checkVersionedTableExists;
+    /**
+     * Register a new table version
+     */
+    private registerTableVersion;
+    /**
+     * Check if a table has versioning enabled
+     */
+    hasVersioning(tableName: string): boolean;
+    /**
+     * Check if a table has soft delete enabled
+     */
+    hasSoftDelete(tableName: string): boolean;
+    /**
+     * Execute all pending reinitTable functions
+     */
+    executeReinitTables(dataStorage: any): Promise<void>;
+    readWriteTransaction(stores?: string[]): PostgreSQLReadWriteTransaction;
+    readTransaction(stores?: string[]): PostgreSQLReadTransaction;
+}
+export declare const createPostgreSQLAdapterFactory: (db: PostgreSQLDatabase) => DBAdapterFactory;
+export {};
+//# sourceMappingURL=postgresAdapter.d.ts.map

package/dist/db/sqliteAdapter.d.ts

@@ -8,11 +8,13 @@ export interface SQLiteDatabase {
 declare class SQLiteReadTransaction implements ReadTransaction {
     protected db: SQLiteDatabase;
     protected tables: Map<string, StoreTable>;
-    constructor(db: SQLiteDatabase, tables: Map<string, StoreTable>);
+    protected adapter?: SQLiteAdapter | undefined;
+    constructor(db: SQLiteDatabase, tables: Map<string, StoreTable>, adapter?: SQLiteAdapter | undefined);
+    protected hasSoftDelete(tableName: string): boolean;
     protected deserializeValue(value: any, column: StoreColumn): any;
     protected deserializeRow(row: any, table: StoreTable): any;
     protected getId(store: string, id: any): any;
-    protected buildWhereClause(where?: WhereCondition): {
+    protected buildWhereClause(where?: WhereCondition, tableName?: string): {
         sql: string;
         params: any[];
     };
@@ -21,8 +23,12 @@ declare class SQLiteReadTransaction implements ReadTransaction {
     find<T>(store: string, options: FindOptions<T>): Promise<T[]>;
 }
 declare class SQLiteReadWriteTransaction extends SQLiteReadTransaction implements ReadWriteTransaction {
+    protected adapter: SQLiteAdapter;
+    constructor(db: SQLiteDatabase, tables: Map<string, StoreTable>, adapter: SQLiteAdapter);
     remove(store: string, id: any): Promise<void>;
     set(store: string, item: any): Promise<void>;
+    private setWithoutVersioning;
+    private setWithVersioning;
     commit(): Promise<void>;
     private serializeValue;
 }
@@ -30,9 +36,47 @@ export declare class SQLiteAdapter implements DatabaseAdapter {
     private db;
     private context;
     private tables;
+    private tableSchemas;
+    private pendingReinitTables;
+    private mapType;
+    private buildConstraints;
+    private generateColumnSQL;
+    private generateCreateTableSQL;
     constructor(db: SQLiteDatabase, context: ArcContextAny);
     initialize(): Promise<void>;
-    private createTableIfNotExists;
+    private createTableIfNotExistsNew;
+    /**
+     * Create the version counter table for tracking per-table version sequences
+     */
+    private createVersionCounterTable;
+    /**
+     * Create the table versions tracking table for schema versioning
+     */
+    private createTableVersionsTable;
+    /**
+     * Generate physical table name with version suffix
+     */
+    private getPhysicalTableName;
+    /**
+     * Check if a versioned table exists
+     */
+    private checkVersionedTableExists;
+    /**
+     * Register a new table version
+     */
+    private registerTableVersion;
+    /**
+     * Check if a table has versioning enabled
+     */
+    hasVersioning(tableName: string): boolean;
+    /**
+     * Check if a table has soft delete enabled
+     */
+    hasSoftDelete(tableName: string): boolean;
+    /**
+     * Execute all pending reinitTable functions
+     */
+    executeReinitTables(dataStorage: any): Promise<void>;
     readWriteTransaction(stores?: string[]): SQLiteReadWriteTransaction;
     readTransaction(stores?: string[]): SQLiteReadTransaction;
 }

package/dist/elements/abstract.d.ts

@@ -1,3 +1,4 @@
+import type { DatabaseAgnosticColumnInfo, DatabaseStoreData } from "../database/database-store";
 import { ArcBranded } from "./branded";
 import { ArcDefault } from "./default";
 import type { ArcElement } from "./element";
@@ -12,6 +13,7 @@ export type GetValidator<A extends ArcAbstract<any>> = A extends ArcAbstract<inf
 export declare abstract class ArcAbstract<V extends Validators> implements ArcElement {
     protected validations: V;
     protected _description?: string;
+    protected _storeData?: DatabaseStoreData;
     constructor(validations?: V);
     abstract serialize(value: any): any;
     abstract deserialize(value: any): any;
@@ -31,6 +33,32 @@ export declare abstract class ArcAbstract<V extends Validators> implements ArcEl
      */
     toJsonSchema(): any;
     getValidations(): V;
+    /**
+     * Database store configuration methods
+     */
+    /** Mark this field as primary key */
+    primaryKey(): this;
+    /** Mark this field as auto-increment */
+    autoIncrement(): this;
+    /** Mark this field as unique */
+    unique(): this;
+    /** Add index to this field */
+    index(): this;
+    /** Add foreign key relationship */
+    foreignKey(table: string, column: string, options?: {
+        onDelete?: "CASCADE" | "SET NULL" | "RESTRICT";
+        onUpdate?: "CASCADE" | "SET NULL" | "RESTRICT";
+    }): this;
+    /** Override database type for specific database */
+    databaseType(overrides: DatabaseStoreData["databaseType"]): this;
+    /** Add database-specific column options */
+    columnOptions(options: DatabaseStoreData["columnOptions"]): this;
+    /** Get store data for database schema generation */
+    getStoreData(): DatabaseStoreData | undefined;
+    /**
+     * Generate database-agnostic column information from this ArcObject
+     */
+    abstract getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export type ArcAbstractAny = ArcAbstract<any>;
 //# sourceMappingURL=abstract.d.ts.map

package/dist/elements/any.d.ts

@@ -1,10 +1,12 @@
 import { ArcAbstract, type Validators } from "./abstract";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 export declare class ArcAny<T, V extends Validators = []> extends ArcAbstract<V> {
     constructor();
     parse(value: T): any;
     serialize(value: T): any;
     deserialize(value: any): T;
     toJsonSchema(): any;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export declare function any<T extends any>(): ArcAny<T, any>;
 //# sourceMappingURL=any.d.ts.map

package/dist/elements/array.d.ts

@@ -1,6 +1,7 @@
 import { type util } from "../utils";
 import { ArcAbstract, type CheckFn, type GetValidator, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 declare const arrayValidator: {
     name: "type";
     validator: (value: any) => false | {
@@ -55,6 +56,8 @@ export declare class ArcArray<E extends ArcElement, V extends Validators = [
         validator: Fn;
     }]>>>;
     toJsonSchema(): any;
+    /** Generate database-agnostic column information */
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export type ArcArrayAny = ArcArray<any>;
 export declare function array<E extends ArcElement>(element: E): ArcArray<E, [{

package/dist/elements/blob.d.ts

@@ -1,5 +1,6 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 declare const blobValidator: {
     readonly name: "blob";
     readonly validator: (value: any) => {
@@ -68,6 +69,7 @@ export declare class ArcBlob<V extends Validators = [typeof blobValidator]> exte
      */
     parse(value: any): Blob;
     toJsonSchema(): any;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export declare function blob(): ArcBlob<[{
     readonly name: "blob";

package/dist/elements/boolean.d.ts

@@ -1,3 +1,4 @@
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
 export declare class ArcBoolean<V extends Validators> extends ArcPrimitive<V, boolean> {
@@ -12,6 +13,8 @@ export declare class ArcBoolean<V extends Validators> extends ArcPrimitive<V, bo
         validator: Fn;
     }]>>>;
     toJsonSchema(): any;
+    /** Generate database-agnostic column information */
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export declare function boolean(): ArcBoolean<Validators>;
 //# sourceMappingURL=boolean.d.ts.map

package/dist/elements/branded.d.ts

@@ -2,6 +2,7 @@ import { type util } from "../utils";
 import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
 import { ArcOptional } from "./optional";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string | symbol> implements ArcElement {
     private parent;
     private brand;
@@ -18,6 +19,7 @@ export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string |
     optional(): ArcOptional<this>;
     validate(value: unknown): unknown;
     toJsonSchema(): any;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export type ArcBrandedAny = ArcBranded<ArcAbstractAny, any>;
 //# sourceMappingURL=branded.d.ts.map

package/dist/elements/date.d.ts

@@ -1,5 +1,6 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcAbstract } from "./abstract";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 declare const dateValidator: {
     name: "type";
     validator: (value: any) => false | {
@@ -31,6 +32,8 @@ export declare class ArcDate<V extends Validators = [typeof dateValidator]> exte
         validator: Fn;
     }]>>>;
     toJsonSchema(): any;
+    /** Generate database-agnostic column information */
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export declare function date(): ArcDate<[{
     name: "type";

package/dist/elements/default.d.ts

@@ -1,5 +1,6 @@
 import { type util } from "../utils";
 import type { ArcElement } from "./element";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     private parent;
     private defaultValueOrCallback;
@@ -9,5 +10,6 @@ export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
     deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;
     toJsonSchema(): any;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 //# sourceMappingURL=default.d.ts.map

package/dist/elements/file.d.ts

@@ -1,5 +1,6 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 declare const fileValidator: {
     readonly name: "file";
     readonly validator: (value: any) => {
@@ -128,6 +129,7 @@ export declare class ArcFile<V extends Validators = [typeof fileValidator]> exte
      */
     parse(value: any): File;
     toJsonSchema(): any;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export declare function file(): ArcFile<[{
     readonly name: "file";

package/dist/elements/number.d.ts

@@ -1,5 +1,6 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 declare const numberValidator: {
     name: "type";
     validator: (value: any) => false | {
@@ -28,6 +29,8 @@ export declare class ArcNumber<V extends Validators = [typeof numberValidator]>
         validator: Fn;
     }]>>>;
     toJsonSchema(): any;
+    /** Generate database-agnostic column information */
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export declare function number(): ArcNumber<[{
     name: "type";

package/dist/elements/object.d.ts

@@ -1,3 +1,4 @@
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 import { type objectUtil, type util } from "../utils";
 import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
@@ -64,6 +65,10 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
     entries(): [string, ArcElement][];
     toJsonSchema(): any;
+    /** Generate database-agnostic column information */
+    getColumnData(): DatabaseAgnosticColumnInfo;
+    /** Merge this ArcObject with another shape */
+    merge<OtherShape extends ArcRawShape>(otherShape: OtherShape): ArcObject<E & OtherShape, V>;
 }
 export type ArcObjectAny = ArcObject<any, any>;
 export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E, any> ? Exclude<keyof E, symbol> : never;

package/dist/elements/optional.d.ts

@@ -1,6 +1,7 @@
 import { type util } from "../utils";
 import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     private parent;
     constructor(parent: E);
@@ -11,6 +12,7 @@ export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     toJsonSchema(): {
         anyOf: any[];
     };
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export type ArcOptionalAny = ArcOptional<ArcAbstractAny>;
 //# sourceMappingURL=optional.d.ts.map

package/dist/elements/or.d.ts

@@ -1,5 +1,6 @@
 import { type util } from "../utils";
 import type { ArcElement } from "./element";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 /**
  * ArcOr allows you to create a union schema from existing Arc elements.
  * The generic parameter keeps the type-information of every provided
@@ -30,6 +31,7 @@ export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
     toJsonSchema(): {
         anyOf: any[];
     };
+    getColumnData(): DatabaseAgnosticColumnInfo;
     private pickElement;
     private isTypeOf;
 }

package/dist/elements/record.d.ts

@@ -4,6 +4,7 @@ import type { ArcElement } from "./element";
 import type { ArcId } from "./id";
 import type { ArcNumber } from "./number";
 import type { ArcString } from "./string";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 type ArcKey = ArcString<any> | ArcNumber | ArcId<any>;
 export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V extends Validators = [
     {
@@ -20,6 +21,7 @@ export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V exten
     serialize(value: Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>): Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>;
     deserialize(value: Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>): Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>;
     toJsonSchema(): any;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export type ArcRecordAny = ArcRecord<any, any>;
 export declare function record<Key extends ArcKey, E extends ArcElement>(key: Key, element: E): ArcRecord<Key, E, [{

package/dist/elements/string-enum.d.ts

@@ -1,4 +1,5 @@
 import { ArcAbstract, type Validators } from "./abstract";
+import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 export declare class ArcStringEnum<const T extends string[], V extends Validators = [
     {
         name: "schema";
@@ -15,6 +16,7 @@ export declare class ArcStringEnum<const T extends string[], V extends Validator
     deserialize<Value extends T[number]>(value: Value): Value;
     toJsonSchema(): any;
     getEnumerators(): T;
+    getColumnData(): DatabaseAgnosticColumnInfo;
 }
 export type ArcStringEnumAny = ArcStringEnum<any>;
 export declare function stringEnum<const T extends string[]>(...values: T): ArcStringEnum<T, [{