Function syncTable

packages/cli/src/actions/pull/index.ts:112–386

({
    model,
    provider,
    table,
    services,
    options,
    defaultSchema,
}: {
    table: IntrospectedTable;
    model: Model;
    oldModel: Model;
    provider: IntrospectionProvider;
    services: ZModelServices;
    options: PullOptions;
    defaultSchema: string;
})

};

export function syncTable({
    model,
    provider,
    table,
    services,
    options,
    defaultSchema,
}: {
    table: IntrospectedTable;
    model: Model;
    oldModel: Model;
    provider: IntrospectionProvider;
    services: ZModelServices;
    options: PullOptions;
    defaultSchema: string;
}) {
    const idAttribute = getAttributeRef('@id', services);
    const modelIdAttribute = getAttributeRef('@@id', services);
    const uniqueAttribute = getAttributeRef('@unique', services);
    const modelUniqueAttribute = getAttributeRef('@@unique', services);
    const fieldMapAttribute = getAttributeRef('@map', services);
    const tableMapAttribute = getAttributeRef('@@map', services);
    const modelindexAttribute = getAttributeRef('@@index', services);

    const relations: Relation[] = [];
    const { name, modified } = resolveNameCasing(options.modelCasing, table.name);
    const multiPk = table.columns.filter((c) => c.pk).length > 1;

    const modelFactory = new DataModelFactory().setName(name).setIsView(table.type === 'view');
    modelFactory.setContainer(model);

    if (modified || options.alwaysMap) {
        modelFactory.addAttribute((builder) =>
            builder.setDecl(tableMapAttribute).addArg((argBuilder) => argBuilder.StringLiteral.setValue(table.name)),
        );
    }
    // Group FK columns by constraint name to handle composite foreign keys.
    // Each FK constraint (identified by fk_name) may span multiple columns.
    const fkGroups = new Map<string, typeof table.columns>();
    table.columns.forEach((column) => {
        if (column.foreign_key_table && column.foreign_key_name) {
            const group = fkGroups.get(column.foreign_key_name) ?? [];
            group.push(column);
            fkGroups.set(column.foreign_key_name, group);
        }
    });

    for (const [fkName, fkColumns] of fkGroups) {
        const firstCol = fkColumns[0]!;
        // For single-column FKs, check if the column is the table's single-column PK (one-to-one)
        const isSingleColumnPk = fkColumns.length === 1 && !multiPk && firstCol.pk;
        // A single-column FK with unique constraint means one-to-one on the opposite side
        const isUniqueRelation = (fkColumns.length === 1 && firstCol.unique) || isSingleColumnPk;
        relations.push({
            schema: table.schema,
            table: table.name,
            columns: fkColumns.map((c) => c.name),
            type: 'one',