@peers-app/peers-sdk 0.8.23 → 0.9.1

package/dist/data/orm/table-container.js

@@ -1,15 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableContainer = void 0;
+exports.checkVersionedUpdate = checkVersionedUpdate;
 const types_1 = require("./types");
 const table_1 = require("./table");
 const table_definitions_system_1 = require("./table-definitions.system");
 const utils_1 = require("../../utils");
+const rpc_types_1 = require("../../rpc-types");
+/**
+ * Compare two table definition versions and decide whether to update.
+ * @returns 'update' when incoming version is strictly newer, 'skip' otherwise.
+ * Logs an error if same version but different definitions (caller should bump versionNumber).
+ */
+function checkVersionedUpdate(existingVersion, incomingVersion, existingMetaData, incomingMetaData) {
+    if (existingVersion < incomingVersion) {
+        return 'update';
+    }
+    if (existingVersion === incomingVersion) {
+        const sameDefinition = (0, utils_1.simpleObjectHash)(existingMetaData) === (0, utils_1.simpleObjectHash)(incomingMetaData);
+        if (!sameDefinition) {
+            const tableName = (0, utils_1.getFullTableName)(existingMetaData);
+            console.error(`Table "${tableName}" has two different definitions with the same versionNumber (${existingMetaData.versionNumber}). Skipping update. Increment versionNumber when changing table definitions.`);
+        }
+    }
+    return 'skip';
+    // commenting this out for now, it's too likely to end up in an infinite loop
+    // if (existingVersion > incomingVersion) {
+    //   return 'skip';
+    // }
+    // if (existingVersion === incomingVersion) {
+    //   const sameDefinition = simpleObjectHash(existingMetaData) === simpleObjectHash(incomingMetaData);
+    //   if (sameDefinition) {
+    //     return 'skip'; // same version, same definition — nothing to do
+    //   }
+    //   if (!incomingVersion) {
+    //     return 'update-warn-unversioned';
+    //   }
+    //   return 'skip-warn-conflict';
+    // }
+    // return 'update'; // incoming is strictly newer
+}
 class TableContainer {
     tableFactory;
     groupId;
     tableDefinitions = {};
     tableInstances = {};
+    savingDefinitions = false;
+    // Fallback tier: bare-bones definitions from synced TableDefinitionRecords (no custom constructors).
+    // These live in a separate map so they never block full instances from being created.
+    fallbackDefinitions = {};
+    fallbackInstances = {};
+    fallbackSubscribed = false;
     constructor(tableFactory, groupId) {
         this.tableFactory = tableFactory;
         this.groupId = groupId;
@@ -26,6 +67,10 @@ class TableContainer {
             return;
         }
         if (existing && opts?.overwrite) {
+            const existingDef = this.tableDefinitions[tableName];
+            if (existingDef && (0, utils_1.simpleObjectHash)(existingDef.metaData) === (0, utils_1.simpleObjectHash)(tableDefinition.metaData)) {
+                return; // definition hasn't changed, no need to overwrite
+            }
             console.warn(`Overwriting table definition for ${tableName}.`);
             delete this.tableInstances[tableName];
         }
@@ -63,34 +108,183 @@ class TableContainer {
             const TableClass = tableConstructor || registeredDef?.tableConstructor || (table_1.Table);
             const table = this.tableFactory(metaData, schema, TableClass, this.groupId);
             this.tableInstances[tableName] = table;
+            this.saveTableDefinition(metaData);
         }
         return this.tableInstances[tableName];
     }
+    /**
+     * Auto-save table definition to the TableDefinitions system table.
+     * Only runs on server side, only for tables with a tableId (skips system tables),
+     * and skips saving the TableDefinitions table itself to avoid recursion.
+     */
+    saveTableDefinition(metaData) {
+        if (rpc_types_1.isClient)
+            return;
+        if (!metaData.tableId)
+            return; // system tables don't need to be saved
+        if (metaData.name === 'TableDefinitions')
+            return; // avoid recursion
+        if (this.savingDefinitions)
+            return; // guard against re-entrant calls
+        this.savingDefinitions = true;
+        const tableName = (0, utils_1.getFullTableName)(metaData);
+        try {
+            // Lazy import to avoid circular dependency at module load time
+            const { TableDefinitions } = require('../table-definitions-table');
+            const tableDefsTable = TableDefinitions();
+            const record = {
+                tableId: metaData.tableId,
+                name: tableName,
+                metaData: metaData,
+                versionNumber: metaData.versionNumber ?? 0,
+            };
+            // Fire-and-forget: check if existing record has a newer versionNumber
+            tableDefsTable.get(metaData.tableId).then(existing => {
+                if (existing) {
+                    const result = checkVersionedUpdate(existing.versionNumber, record.versionNumber, existing.metaData, record.metaData);
+                    if (result === 'skip') {
+                        return;
+                    }
+                }
+                return tableDefsTable.save(record, { restoreIfDeleted: true, saveAsSnapshot: true });
+            }).catch(err => {
+                console.warn(`Failed to save table definition for ${tableName}:`, err);
+            }).finally(() => {
+                this.savingDefinitions = false;
+            });
+        }
+        catch (err) {
+            console.warn(`Failed to save table definition for ${tableName}:`, err);
+            this.savingDefinitions = false;
+        }
+    }
     getTableByName(tableName) {
+        // 1. Check for a full instance (from code/packages)
         if (this.tableInstances[tableName]) {
-            // If the table is already instantiated, return it
             return this.tableInstances[tableName];
         }
+        // 2. Check for a full definition (code-registered or system) and instantiate it
         const tableDefinition = this.tableDefinitions[tableName] || table_definitions_system_1.systemTableDefinitions[tableName];
-        if (!tableDefinition) {
-            throw new Error(`There is no instantiated table or registered definition for ${tableName}`);
+        if (tableDefinition) {
+            const { metaData, schema, tableConstructor } = tableDefinition;
+            return this.getTable(metaData, schema, tableConstructor);
+        }
+        // 3. Check for a fallback instance (from synced TableDefinitionRecords)
+        if (this.fallbackInstances[tableName]) {
+            return this.fallbackInstances[tableName];
+        }
+        // 4. Check for a fallback definition and create a fallback instance
+        const fallbackDef = this.fallbackDefinitions[tableName];
+        if (fallbackDef) {
+            const { metaData, schema } = fallbackDef;
+            const table = this.tableFactory(metaData, schema ?? (0, types_1.fieldsToSchema)(metaData.fields), table_1.Table, this.groupId);
+            this.fallbackInstances[tableName] = table;
+            return table;
+        }
+        throw new Error(`There is no instantiated table or registered definition for ${tableName}`);
+    }
+    /**
+     * Lazily look up a fallback table by name from the TableDefinitions system table.
+     * On first call, subscribes to TableDefinitions.dataChanged so future synced
+     * records are auto-registered (and removed on delete).
+     * Returns the table instance if found, or null if no definition exists.
+     */
+    async getFallbackTable(tableName) {
+        // Already have an instance or definition from a previous lookup
+        if (this.fallbackInstances[tableName])
+            return this.fallbackInstances[tableName];
+        if (this.fallbackDefinitions[tableName]) {
+            const { metaData, schema } = this.fallbackDefinitions[tableName];
+            const table = this.tableFactory(metaData, schema ?? (0, types_1.fieldsToSchema)(metaData.fields), table_1.Table, this.groupId);
+            this.fallbackInstances[tableName] = table;
+            return table;
+        }
+        const tableDefsTable = this.tableInstances['TableDefinitions'];
+        if (!tableDefsTable)
+            return null;
+        // Subscribe once so future changes are picked up automatically
+        if (!this.fallbackSubscribed) {
+            this.fallbackSubscribed = true;
+            tableDefsTable.dataChanged.subscribe((event) => {
+                if (event.op === 'delete') {
+                    const md = event.dataObject?.metaData;
+                    if (md) {
+                        const name = (0, utils_1.getFullTableName)(md);
+                        delete this.fallbackDefinitions[name];
+                        delete this.fallbackInstances[name];
+                    }
+                    return;
+                }
+                this.registerFromTableDefinitionRecord(event.dataObject);
+            });
+        }
+        // Query for this specific table definition
+        const record = await tableDefsTable.findOne({ name: tableName });
+        if (!record)
+            return null;
+        this.registerFromTableDefinitionRecord(record);
+        // Now instantiate via getTableByName which checks fallbackDefinitions
+        return this.getTableByName(tableName);
+    }
+    /**
+     * Register a table definition from a synced TableDefinitions record.
+     * These go into the fallback tier (no custom constructor) so they never
+     * block full code-defined instances from being created later.
+     *
+     * Called automatically by the getFallbackTable dataChanged subscription.
+     * External code should not need to call this directly.
+     */
+    registerFromTableDefinitionRecord(record) {
+        const metaData = record.metaData;
+        if (!metaData?.tableId || !metaData?.name || !metaData?.fields) {
+            console.warn(`Invalid table definition record, skipping:`, record);
+            return;
+        }
+        const tableName = (0, utils_1.getFullTableName)(metaData);
+        // Don't overwrite a full (code-registered) definition -- that always takes precedence
+        const fullDef = this.tableDefinitions[tableName] || table_definitions_system_1.systemTableDefinitions[tableName];
+        if (fullDef) {
+            return; // full definition exists, no need for a fallback
         }
-        const { metaData, schema, tableConstructor } = tableDefinition;
-        return this.getTable(metaData, schema, tableConstructor);
+        const existing = this.fallbackDefinitions[tableName];
+        if (existing) {
+            const existingVersion = existing.metaData.versionNumber ?? 0;
+            const incomingVersion = record.versionNumber ?? 0;
+            const result = checkVersionedUpdate(existingVersion, incomingVersion, existing.metaData, metaData);
+            if (result === 'skip') {
+                return;
+            }
+            // Remove old fallback instance so it gets re-created with the new schema
+            delete this.fallbackInstances[tableName];
+        }
+        const schema = (0, types_1.fieldsToSchema)(metaData.fields);
+        this.fallbackDefinitions[tableName] = { metaData, schema };
     }
     /**
      * This ensures all tables have been new'ed up and then returns the entire list of them.
+     * Full (code-defined) instances take precedence over fallback (synced-definition) instances.
      *
      * This is primarily intended to be used by the peer-device sync operation which needs all
      * tables to be able to apply changes correctly.
     */
     getAllTables() {
-        const allDefinitions = [...Object.values(table_definitions_system_1.systemTableDefinitions), ...Object.values(this.tableDefinitions)];
-        for (const tableDefinition of allDefinitions) {
+        // 1. Instantiate all full definitions (system + code-registered)
+        const fullDefinitions = [...Object.values(table_definitions_system_1.systemTableDefinitions), ...Object.values(this.tableDefinitions)];
+        for (const tableDefinition of fullDefinitions) {
             const { metaData, schema, tableConstructor } = tableDefinition;
             this.getTable(metaData, schema, tableConstructor);
         }
-        return Object.values(this.tableInstances);
+        // 2. Instantiate fallback definitions that don't already have a full instance
+        for (const [tableName, fallbackDef] of Object.entries(this.fallbackDefinitions)) {
+            if (!this.tableInstances[tableName] && !this.fallbackInstances[tableName]) {
+                const { metaData, schema } = fallbackDef;
+                const table = this.tableFactory(metaData, schema ?? (0, types_1.fieldsToSchema)(metaData.fields), table_1.Table, this.groupId);
+                this.fallbackInstances[tableName] = table;
+            }
+        }
+        // 3. Merge: full instances take precedence, then add fallbacks for tables not in full
+        const result = { ...this.fallbackInstances, ...this.tableInstances };
+        return Object.values(result);
     }
 }
 exports.TableContainer = TableContainer;

package/dist/data/orm/table-container.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/data/orm/table-container.test.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const table_container_1 = require("./table-container");
+const event_registry_1 = require("./event-registry");
+const client_proxy_data_source_1 = require("./client-proxy.data-source");
+const table_1 = require("./table");
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+describe('checkVersionedUpdate', () => {
+    const metaA = { name: 'TestTable', fields: [{ name: 'id', type: 'string' }] };
+    const metaAReordered = { fields: [{ name: 'id', type: 'string' }], name: 'TestTable' };
+    const metaB = { name: 'TestTable', fields: [{ name: 'id', type: 'number' }] };
+    it('should skip when existing version is strictly newer', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(200, 100, metaA, metaB)).toBe('skip');
+    });
+    it('should update when incoming version is strictly newer', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 200, metaA, metaB)).toBe('update');
+    });
+    it('should skip when same non-zero version and same definition', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaA)).toBe('skip');
+    });
+    it('should skip when same non-zero version and same definition with different key order', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaAReordered)).toBe('skip');
+    });
+    it('should skip when same non-zero version but different definitions', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaB)).toBe('skip');
+    });
+    it('should skip when both versions are 0 and definitions are the same', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaA)).toBe('skip');
+    });
+    it('should skip when both versions are 0 and definitions are the same with different key order', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaAReordered)).toBe('skip');
+    });
+    it('should skip when both versions are 0 and definitions differ', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaB)).toBe('skip');
+    });
+    it('should update when incoming is newer regardless of definition content', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaA)).toBe('update');
+        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaB)).toBe('update');
+    });
+    it('should skip when existing is newer regardless of definition content', () => {
+        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaA)).toBe('skip');
+        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaB)).toBe('skip');
+    });
+});
+// --- Tiered table instance tests ---
+// Custom Table subclass for testing
+class CustomTestTable extends table_1.Table {
+    customMethod() {
+        return 'custom';
+    }
+}
+function createTestHarness() {
+    const mockDataContext = { dataContextId: 'test-context' };
+    const eventRegistry = new event_registry_1.EventRegistry(mockDataContext);
+    const tableFactory = jest.fn().mockImplementation((metaData, schema, TableClass) => {
+        const deps = {
+            dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, 'test-context'),
+            eventRegistry,
+        };
+        return new (TableClass || table_1.Table)(metaData, deps);
+    });
+    const container = new table_container_1.TableContainer(tableFactory);
+    const tableId = (0, utils_1.newid)();
+    const testMetaData = {
+        tableId,
+        name: 'TestPkgTable',
+        description: 'A package-defined table',
+        primaryKeyName: 'id',
+        fields: [
+            { name: 'id', type: field_type_1.FieldType.id },
+            { name: 'title', type: field_type_1.FieldType.string },
+        ],
+    };
+    const testSchema = zod_1.z.object({
+        id: zod_1.z.string(),
+        title: zod_1.z.string(),
+    });
+    const defRecord = {
+        tableId,
+        name: `TestPkgTable_${tableId}`,
+        metaData: testMetaData,
+        versionNumber: 0,
+    };
+    return { container, testMetaData, testSchema, defRecord, tableFactory };
+}
+describe('Tiered table instances', () => {
+    it('bare-bones fallback instance should NOT block full instance with custom constructor', () => {
+        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
+        // Simulate sync: register from a TableDefinitionRecord (no custom constructor)
+        // (method is private — normally auto-called via dataChanged subscription)
+        container.registerFromTableDefinitionRecord(defRecord);
+        // Sync code calls getTableByName to get a working instance
+        const fallbackTable = container.getTableByName(defRecord.name);
+        expect(fallbackTable).toBeInstanceOf(table_1.Table);
+        expect(fallbackTable).not.toBeInstanceOf(CustomTestTable);
+        // Later, package code calls getTable with the full custom constructor
+        const fullTable = container.getTable(testMetaData, testSchema, CustomTestTable);
+        // The full instance should be a CustomTestTable, NOT the bare-bones Table
+        expect(fullTable).toBeInstanceOf(CustomTestTable);
+        expect(fullTable.customMethod()).toBe('custom');
+    });
+    it('getTableByName should return full instance when one exists', () => {
+        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
+        // Register fallback definition (private — normally auto-called)
+        container.registerFromTableDefinitionRecord(defRecord);
+        // Package code creates the full instance first
+        const fullTable = container.getTable(testMetaData, testSchema, CustomTestTable);
+        expect(fullTable).toBeInstanceOf(CustomTestTable);
+        // getTableByName should return the full instance, not create a new bare one
+        const byName = container.getTableByName(defRecord.name);
+        expect(byName).toBe(fullTable);
+        expect(byName).toBeInstanceOf(CustomTestTable);
+    });
+    it('getTableByName should return fallback instance when no full instance exists', () => {
+        const { container, defRecord } = createTestHarness();
+        // Only register from definition record -- no full definition available (private — normally auto-called)
+        container.registerFromTableDefinitionRecord(defRecord);
+        // Should return a bare-bones Table instance
+        const table = container.getTableByName(defRecord.name);
+        expect(table).toBeInstanceOf(table_1.Table);
+        expect(table).not.toBeInstanceOf(CustomTestTable);
+    });
+    it('getAllTables should prefer full instances over fallback instances', () => {
+        const { container, testMetaData, testSchema, defRecord, tableFactory } = createTestHarness();
+        // Create a second table that will only have a fallback definition
+        const tableId2 = (0, utils_1.newid)();
+        const metaData2 = {
+            tableId: tableId2,
+            name: 'OtherTable',
+            description: 'Another table',
+            primaryKeyName: 'id',
+            fields: [
+                { name: 'id', type: field_type_1.FieldType.id },
+                { name: 'value', type: field_type_1.FieldType.string },
+            ],
+        };
+        const defRecord2 = {
+            tableId: tableId2,
+            name: `OtherTable_${tableId2}`,
+            metaData: metaData2,
+            versionNumber: 0,
+        };
+        // Register both as fallback definitions (private — normally auto-called)
+        container.registerFromTableDefinitionRecord(defRecord);
+        container.registerFromTableDefinitionRecord(defRecord2);
+        // Create full instance for only the first table
+        container.getTable(testMetaData, testSchema, CustomTestTable);
+        // getAllTables should include both tables
+        const allTables = container.getAllTables();
+        const tableNames = allTables.map(t => t.tableName);
+        expect(tableNames).toContain(defRecord.name);
+        expect(tableNames).toContain(defRecord2.name);
+        // The first table should be the full CustomTestTable instance
+        const firstTable = allTables.find(t => t.tableName === defRecord.name);
+        expect(firstTable).toBeInstanceOf(CustomTestTable);
+        // The second table should be a bare-bones Table (fallback)
+        const secondTable = allTables.find(t => t.tableName === defRecord2.name);
+        expect(secondTable).toBeInstanceOf(table_1.Table);
+        expect(secondTable).not.toBeInstanceOf(CustomTestTable);
+    });
+});

package/dist/data/orm/table.d.ts

@@ -10,6 +10,7 @@ export declare class Table<T extends {
     readonly tableName: string;
     readonly primaryKeyName: string;
     readonly schema: z.AnyZodObject;
+    private readonly codeSchema?;
     protected readonly dataChangedEmitter: Emitter<IDataChangedEvent<T>>;
     readonly dataChanged: Event<IDataChangedEvent<T>>;
     private readonly localOperationCache;

package/dist/data/orm/table.js

@@ -14,6 +14,7 @@ class Table {
     tableName;
     primaryKeyName;
     schema;
+    codeSchema;
     dataChangedEmitter;
     dataChanged;
     localOperationCache = new Map();
@@ -23,7 +24,8 @@ class Table {
     constructor(metaData, deps) {
         this.metaData = metaData;
         this.dataSource = deps.dataSource;
-        this.schema = deps.schema || (0, types_1.fieldsToSchema)(metaData.fields);
+        this.codeSchema = deps.schema;
+        this.schema = (0, types_1.fieldsToSchema)(metaData.fields, deps.schema);
         this.groupId = deps.groupId;
         this.tableName = (0, utils_1.getFullTableName)(metaData);
         this.primaryKeyName = metaData.primaryKeyName;
@@ -43,7 +45,7 @@ class Table {
         // Find any underlying SubscribableDataSource to intercept its events
         let subscribableDataSource = undefined;
         let _dataSource = this.dataSource;
-        while (!subscribableDataSource && _dataSource) {
+        while (_dataSource) {
             if (!subscribableDataSource && _dataSource instanceof subscribable_data_source_1.SubscribableDataSource) {
                 subscribableDataSource = _dataSource;
             }
@@ -219,6 +221,16 @@ class Table {
     initRecord(data = {}) {
         const defaults = {};
         for (const field of this.metaData.fields) {
+            // Apply code schema first (has original defaults like () => new Date())
+            if (this.codeSchema?.shape?.[field.name]) {
+                const codeValue = this.codeSchema.shape[field.name].safeParse(data[field.name]);
+                if (codeValue.success) {
+                    // @ts-ignore
+                    defaults[field.name] = codeValue.data;
+                    continue;
+                }
+            }
+            // Fall back to merged schema (fields-derived + code schema intersection)
             const zodField = this.schema.shape[field.name];
             const value = zodField.safeParse(data[field.name]);
             if (value.success) {

package/dist/data/orm/types.d.ts

@@ -15,6 +15,7 @@ export interface ITableMetaData {
     }[];
     iconClassName?: string;
     localOnly?: boolean;
+    versionNumber?: number;
 }
-export declare function fieldsToSchema(fields: IField[]): z.AnyZodObject;
+export declare function fieldsToSchema(fields: IField[], codeSchema?: z.AnyZodObject): z.AnyZodObject;
 export declare function schemaToFields(schema: z.AnyZodObject): IField[];

package/dist/data/orm/types.js

@@ -5,7 +5,7 @@ exports.schemaToFields = schemaToFields;
 const zod_1 = require("zod");
 const field_type_1 = require("../../types/field-type");
 const utils_1 = require("../../utils");
-function fieldsToSchema(fields) {
+function fieldsToSchema(fields, codeSchema) {
     let argsSchema = zod_1.z.object({});
     for (const argSchema of fields) {
         const { name, description, type, isArray, defaultValue, optional } = argSchema;
@@ -13,6 +13,7 @@ function fieldsToSchema(fields) {
         switch (type) {
             case 'id':
                 propertyType = zod_1.z.string().refine((id => (0, utils_1.isid)(id)), { message: 'Invalid id' });
+                propertyType._def._fieldType = field_type_1.FieldType.id;
                 break;
             case 'string':
                 propertyType = zod_1.z.string();
@@ -43,6 +44,9 @@ function fieldsToSchema(fields) {
             propertyType = propertyType.default(defaultValue);
         }
         propertyType = propertyType.describe(description);
+        if (codeSchema?.shape?.[name]) {
+            propertyType = zod_1.z.intersection(propertyType, codeSchema.shape[name]);
+        }
         const newProperty = { [name]: propertyType };
         argsSchema = argsSchema.extend(newProperty);
     }
@@ -55,14 +59,22 @@ function schemaToFields(schema) {
         let type = field_type_1.FieldType.any;
         let _def = field._def;
         let isArray = undefined;
+        let brandedFieldType;
         while (true) {
             if (_def.typeName === 'ZodArray') {
                 isArray = true;
             }
+            if (_def._fieldType) {
+                brandedFieldType = _def._fieldType;
+            }
             if (_def.innerType) {
                 _def = _def.innerType._def;
                 continue;
             }
+            if (_def.schema) {
+                _def = _def.schema._def;
+                continue;
+            }
             if (_def.type) {
                 _def = _def.type._def;
                 continue;
@@ -71,7 +83,7 @@ function schemaToFields(schema) {
         }
         switch (_def.typeName) {
             case 'ZodString':
-                type = field_type_1.FieldType.string;
+                type = brandedFieldType || field_type_1.FieldType.string;
                 break;
             case 'ZodNumber':
                 type = field_type_1.FieldType.number;
@@ -93,9 +105,6 @@ function schemaToFields(schema) {
             default:
                 type = field_type_1.FieldType.any;
         }
-        if ((name === 'id' || name.endsWith('Id')) && type === 'string') {
-            type = field_type_1.FieldType.id;
-        }
         if (!isArray && field._def.typeName === 'ZodArray') {
             isArray = true;
             // isArray = field._def.typeName === 'ZodArray' || undefined;