drizzle-kit 0.20.10-b4cd19e → 0.20.11-6b0f9c7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (7) hide show
  1. package/bin.cjs +7 -6
  2. package/cli/commands/pgIntrospect.d.ts +2 -2
  3. package/package.json +1 -1
  4. package/schemaValidator.d.ts +7 -7
  5. package/serializer/pgSchema.d.ts +89 -89
  6. package/utils.d.ts +2 -2
  7. package/utils.js +6 -5
package/bin.cjs CHANGED
@@ -4907,7 +4907,7 @@ var init_pgSchema = __esm({
4907
4907
  tableFrom: stringType(),
4908
4908
  columnsFrom: stringType().array(),
4909
4909
  tableTo: stringType(),
4910
- schemaTo: stringType(),
4910
+ schemaTo: stringType().optional(),
4911
4911
  columnsTo: stringType().array(),
4912
4912
  onUpdate: stringType().optional(),
4913
4913
  onDelete: stringType().optional()
@@ -12323,7 +12323,7 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
12323
12323
  name,
12324
12324
  tableFrom,
12325
12325
  tableTo,
12326
- schemaTo,
12326
+ schemaTo: schemaTo ?? "public",
12327
12327
  columnsFrom,
12328
12328
  columnsTo,
12329
12329
  onDelete,
@@ -16186,7 +16186,7 @@ ${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT ${statement.newCo
16186
16186
  const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(",");
16187
16187
  const toColumnsString = columnsTo.map((it) => `"${it}"`).join(",");
16188
16188
  const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${tableFrom}"` : `"${tableFrom}"`;
16189
- const tableToNameWithSchema = statement.schema ? `"${schemaTo}"."${tableTo}"` : `"${tableTo}"`;
16189
+ const tableToNameWithSchema = schemaTo ? `"${schemaTo}"."${tableTo}"` : `"${tableTo}"`;
16190
16190
  const alterStatement = `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement}`;
16191
16191
  let sql2 = "DO $$ BEGIN\n";
16192
16192
  sql2 += " " + alterStatement + ";\n";
@@ -16245,8 +16245,9 @@ ${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT ${statement.newCo
16245
16245
  const onUpdateStatement = newFk.onUpdate ? ` ON UPDATE ${newFk.onUpdate}` : "";
16246
16246
  const fromColumnsString = newFk.columnsFrom.map((it) => `"${it}"`).join(",");
16247
16247
  const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(",");
16248
- const tableFromNameWithSchema = statement.schema ? `"${statement.schema}"."${newFk.tableFrom}"` : `"${newFk.tableFrom}"`;
16249
- const alterStatement = `ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES "${newFk.tableTo}"(${toColumnsString})${onDeleteStatement}${onUpdateStatement}`;
16248
+ const tableFromNameWithSchema = oldFk.schemaTo ? `"${oldFk.schemaTo}"."${oldFk.tableFrom}"` : `"${oldFk.tableFrom}"`;
16249
+ const tableToNameWithSchema = newFk.schemaTo ? `"${newFk.schemaTo}"."${newFk.tableFrom}"` : `"${newFk.tableFrom}"`;
16250
+ const alterStatement = `ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement}`;
16250
16251
  sql2 += "DO $$ BEGIN\n";
16251
16252
  sql2 += " " + alterStatement + ";\n";
16252
16253
  sql2 += "EXCEPTION\n";
@@ -62082,7 +62083,7 @@ init_source();
62082
62083
  // package.json
62083
62084
  var package_default = {
62084
62085
  name: "drizzle-kit",
62085
- version: "0.20.10",
62086
+ version: "0.20.11",
62086
62087
  repository: "https://github.com/drizzle-team/drizzle-kit-mirror",
62087
62088
  author: "Drizzle Team",
62088
62089
  license: "MIT",
package/cli/commands/pgIntrospect.d.ts CHANGED
@@ -29,12 +29,12 @@ export declare const pgPushIntrospect: (connection: {
29
29
  foreignKeys: Record<string, {
30
30
  onUpdate?: string | undefined;
31
31
  onDelete?: string | undefined;
32
+ schemaTo?: string | undefined;
32
33
  name: string;
33
34
  tableFrom: string;
34
35
  columnsFrom: string[];
35
36
  tableTo: string;
36
37
  columnsTo: string[];
37
- schemaTo: string;
38
38
  }>;
39
39
  schema: string;
40
40
  compositePrimaryKeys: Record<string, {
@@ -85,12 +85,12 @@ export declare const pgIntrospect: (config: PgConfigIntrospect, filters: string[
85
85
  foreignKeys: Record<string, {
86
86
  onUpdate?: string | undefined;
87
87
  onDelete?: string | undefined;
88
+ schemaTo?: string | undefined;
88
89
  name: string;
89
90
  tableFrom: string;
90
91
  columnsFrom: string[];
91
92
  tableTo: string;
92
93
  columnsTo: string[];
93
- schemaTo: string;
94
94
  }>;
95
95
  schema: string;
96
96
  compositePrimaryKeys: Record<string, {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "drizzle-kit",
3
- "version": "0.20.10-b4cd19e",
3
+ "version": "0.20.11-6b0f9c7",
4
4
  "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
5
5
  "author": "Drizzle Team",
6
6
  "license": "MIT",
package/schemaValidator.d.ts CHANGED
@@ -400,28 +400,28 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
400
400
  tableFrom: import("zod").ZodString;
401
401
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
402
402
  tableTo: import("zod").ZodString;
403
- schemaTo: import("zod").ZodString;
403
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
404
404
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
405
405
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
406
406
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
407
407
  }, "strict", import("zod").ZodTypeAny, {
408
408
  onUpdate?: string | undefined;
409
409
  onDelete?: string | undefined;
410
+ schemaTo?: string | undefined;
410
411
  name: string;
411
412
  tableFrom: string;
412
413
  columnsFrom: string[];
413
414
  tableTo: string;
414
415
  columnsTo: string[];
415
- schemaTo: string;
416
416
  }, {
417
417
  onUpdate?: string | undefined;
418
418
  onDelete?: string | undefined;
419
+ schemaTo?: string | undefined;
419
420
  name: string;
420
421
  tableFrom: string;
421
422
  columnsFrom: string[];
422
423
  tableTo: string;
423
424
  columnsTo: string[];
424
- schemaTo: string;
425
425
  }>>;
426
426
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
427
427
  name: import("zod").ZodString;
@@ -466,12 +466,12 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
466
466
  foreignKeys: Record<string, {
467
467
  onUpdate?: string | undefined;
468
468
  onDelete?: string | undefined;
469
+ schemaTo?: string | undefined;
469
470
  name: string;
470
471
  tableFrom: string;
471
472
  columnsFrom: string[];
472
473
  tableTo: string;
473
474
  columnsTo: string[];
474
- schemaTo: string;
475
475
  }>;
476
476
  schema: string;
477
477
  compositePrimaryKeys: Record<string, {
@@ -508,12 +508,12 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
508
508
  foreignKeys: Record<string, {
509
509
  onUpdate?: string | undefined;
510
510
  onDelete?: string | undefined;
511
+ schemaTo?: string | undefined;
511
512
  name: string;
512
513
  tableFrom: string;
513
514
  columnsFrom: string[];
514
515
  tableTo: string;
515
516
  columnsTo: string[];
516
- schemaTo: string;
517
517
  }>;
518
518
  schema: string;
519
519
  compositePrimaryKeys: Record<string, {
@@ -627,12 +627,12 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
627
627
  foreignKeys: Record<string, {
628
628
  onUpdate?: string | undefined;
629
629
  onDelete?: string | undefined;
630
+ schemaTo?: string | undefined;
630
631
  name: string;
631
632
  tableFrom: string;
632
633
  columnsFrom: string[];
633
634
  tableTo: string;
634
635
  columnsTo: string[];
635
- schemaTo: string;
636
636
  }>;
637
637
  schema: string;
638
638
  compositePrimaryKeys: Record<string, {
@@ -694,12 +694,12 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
694
694
  foreignKeys: Record<string, {
695
695
  onUpdate?: string | undefined;
696
696
  onDelete?: string | undefined;
697
+ schemaTo?: string | undefined;
697
698
  name: string;
698
699
  tableFrom: string;
699
700
  columnsFrom: string[];
700
701
  tableTo: string;
701
702
  columnsTo: string[];
702
- schemaTo: string;
703
703
  }>;
704
704
  schema: string;
705
705
  compositePrimaryKeys: Record<string, {
package/serializer/pgSchema.d.ts CHANGED
@@ -367,28 +367,28 @@ declare const fk: import("zod").ZodObject<{
367
367
  tableFrom: import("zod").ZodString;
368
368
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
369
369
  tableTo: import("zod").ZodString;
370
- schemaTo: import("zod").ZodString;
370
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
371
371
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
372
372
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
373
373
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
374
374
  }, "strict", import("zod").ZodTypeAny, {
375
375
  onUpdate?: string | undefined;
376
376
  onDelete?: string | undefined;
377
+ schemaTo?: string | undefined;
377
378
  name: string;
378
379
  tableFrom: string;
379
380
  columnsFrom: string[];
380
381
  tableTo: string;
381
382
  columnsTo: string[];
382
- schemaTo: string;
383
383
  }, {
384
384
  onUpdate?: string | undefined;
385
385
  onDelete?: string | undefined;
386
+ schemaTo?: string | undefined;
386
387
  name: string;
387
388
  tableFrom: string;
388
389
  columnsFrom: string[];
389
390
  tableTo: string;
390
391
  columnsTo: string[];
391
- schemaTo: string;
392
392
  }>;
393
393
  declare const column: import("zod").ZodObject<{
394
394
  name: import("zod").ZodString;
@@ -466,28 +466,28 @@ declare const tableV3: import("zod").ZodObject<{
466
466
  tableFrom: import("zod").ZodString;
467
467
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
468
468
  tableTo: import("zod").ZodString;
469
- schemaTo: import("zod").ZodString;
469
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
470
470
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
471
471
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
472
472
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
473
473
  }, "strict", import("zod").ZodTypeAny, {
474
474
  onUpdate?: string | undefined;
475
475
  onDelete?: string | undefined;
476
+ schemaTo?: string | undefined;
476
477
  name: string;
477
478
  tableFrom: string;
478
479
  columnsFrom: string[];
479
480
  tableTo: string;
480
481
  columnsTo: string[];
481
- schemaTo: string;
482
482
  }, {
483
483
  onUpdate?: string | undefined;
484
484
  onDelete?: string | undefined;
485
+ schemaTo?: string | undefined;
485
486
  name: string;
486
487
  tableFrom: string;
487
488
  columnsFrom: string[];
488
489
  tableTo: string;
489
490
  columnsTo: string[];
490
- schemaTo: string;
491
491
  }>>;
492
492
  }, "strict", import("zod").ZodTypeAny, {
493
493
  name: string;
@@ -509,12 +509,12 @@ declare const tableV3: import("zod").ZodObject<{
509
509
  foreignKeys: Record<string, {
510
510
  onUpdate?: string | undefined;
511
511
  onDelete?: string | undefined;
512
+ schemaTo?: string | undefined;
512
513
  name: string;
513
514
  tableFrom: string;
514
515
  columnsFrom: string[];
515
516
  tableTo: string;
516
517
  columnsTo: string[];
517
- schemaTo: string;
518
518
  }>;
519
519
  }, {
520
520
  name: string;
@@ -536,12 +536,12 @@ declare const tableV3: import("zod").ZodObject<{
536
536
  foreignKeys: Record<string, {
537
537
  onUpdate?: string | undefined;
538
538
  onDelete?: string | undefined;
539
+ schemaTo?: string | undefined;
539
540
  name: string;
540
541
  tableFrom: string;
541
542
  columnsFrom: string[];
542
543
  tableTo: string;
543
544
  columnsTo: string[];
544
- schemaTo: string;
545
545
  }>;
546
546
  }>;
547
547
  declare const compositePK: import("zod").ZodObject<{
@@ -616,28 +616,28 @@ declare const tableV4: import("zod").ZodObject<{
616
616
  tableFrom: import("zod").ZodString;
617
617
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
618
618
  tableTo: import("zod").ZodString;
619
- schemaTo: import("zod").ZodString;
619
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
620
620
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
621
621
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
622
622
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
623
623
  }, "strict", import("zod").ZodTypeAny, {
624
624
  onUpdate?: string | undefined;
625
625
  onDelete?: string | undefined;
626
+ schemaTo?: string | undefined;
626
627
  name: string;
627
628
  tableFrom: string;
628
629
  columnsFrom: string[];
629
630
  tableTo: string;
630
631
  columnsTo: string[];
631
- schemaTo: string;
632
632
  }, {
633
633
  onUpdate?: string | undefined;
634
634
  onDelete?: string | undefined;
635
+ schemaTo?: string | undefined;
635
636
  name: string;
636
637
  tableFrom: string;
637
638
  columnsFrom: string[];
638
639
  tableTo: string;
639
640
  columnsTo: string[];
640
- schemaTo: string;
641
641
  }>>;
642
642
  }, "strict", import("zod").ZodTypeAny, {
643
643
  name: string;
@@ -659,12 +659,12 @@ declare const tableV4: import("zod").ZodObject<{
659
659
  foreignKeys: Record<string, {
660
660
  onUpdate?: string | undefined;
661
661
  onDelete?: string | undefined;
662
+ schemaTo?: string | undefined;
662
663
  name: string;
663
664
  tableFrom: string;
664
665
  columnsFrom: string[];
665
666
  tableTo: string;
666
667
  columnsTo: string[];
667
- schemaTo: string;
668
668
  }>;
669
669
  schema: string;
670
670
  }, {
@@ -687,12 +687,12 @@ declare const tableV4: import("zod").ZodObject<{
687
687
  foreignKeys: Record<string, {
688
688
  onUpdate?: string | undefined;
689
689
  onDelete?: string | undefined;
690
+ schemaTo?: string | undefined;
690
691
  name: string;
691
692
  tableFrom: string;
692
693
  columnsFrom: string[];
693
694
  tableTo: string;
694
695
  columnsTo: string[];
695
- schemaTo: string;
696
696
  }>;
697
697
  schema: string;
698
698
  }>;
@@ -745,28 +745,28 @@ declare const table: import("zod").ZodObject<{
745
745
  tableFrom: import("zod").ZodString;
746
746
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
747
747
  tableTo: import("zod").ZodString;
748
- schemaTo: import("zod").ZodString;
748
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
749
749
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
750
750
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
751
751
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
752
752
  }, "strict", import("zod").ZodTypeAny, {
753
753
  onUpdate?: string | undefined;
754
754
  onDelete?: string | undefined;
755
+ schemaTo?: string | undefined;
755
756
  name: string;
756
757
  tableFrom: string;
757
758
  columnsFrom: string[];
758
759
  tableTo: string;
759
760
  columnsTo: string[];
760
- schemaTo: string;
761
761
  }, {
762
762
  onUpdate?: string | undefined;
763
763
  onDelete?: string | undefined;
764
+ schemaTo?: string | undefined;
764
765
  name: string;
765
766
  tableFrom: string;
766
767
  columnsFrom: string[];
767
768
  tableTo: string;
768
769
  columnsTo: string[];
769
- schemaTo: string;
770
770
  }>>;
771
771
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
772
772
  name: import("zod").ZodString;
@@ -811,12 +811,12 @@ declare const table: import("zod").ZodObject<{
811
811
  foreignKeys: Record<string, {
812
812
  onUpdate?: string | undefined;
813
813
  onDelete?: string | undefined;
814
+ schemaTo?: string | undefined;
814
815
  name: string;
815
816
  tableFrom: string;
816
817
  columnsFrom: string[];
817
818
  tableTo: string;
818
819
  columnsTo: string[];
819
- schemaTo: string;
820
820
  }>;
821
821
  schema: string;
822
822
  compositePrimaryKeys: Record<string, {
@@ -853,12 +853,12 @@ declare const table: import("zod").ZodObject<{
853
853
  foreignKeys: Record<string, {
854
854
  onUpdate?: string | undefined;
855
855
  onDelete?: string | undefined;
856
+ schemaTo?: string | undefined;
856
857
  name: string;
857
858
  tableFrom: string;
858
859
  columnsFrom: string[];
859
860
  tableTo: string;
860
861
  columnsTo: string[];
861
- schemaTo: string;
862
862
  }>;
863
863
  schema: string;
864
864
  compositePrimaryKeys: Record<string, {
@@ -917,28 +917,28 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
917
917
  tableFrom: import("zod").ZodString;
918
918
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
919
919
  tableTo: import("zod").ZodString;
920
- schemaTo: import("zod").ZodString;
920
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
921
921
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
922
922
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
923
923
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
924
924
  }, "strict", import("zod").ZodTypeAny, {
925
925
  onUpdate?: string | undefined;
926
926
  onDelete?: string | undefined;
927
+ schemaTo?: string | undefined;
927
928
  name: string;
928
929
  tableFrom: string;
929
930
  columnsFrom: string[];
930
931
  tableTo: string;
931
932
  columnsTo: string[];
932
- schemaTo: string;
933
933
  }, {
934
934
  onUpdate?: string | undefined;
935
935
  onDelete?: string | undefined;
936
+ schemaTo?: string | undefined;
936
937
  name: string;
937
938
  tableFrom: string;
938
939
  columnsFrom: string[];
939
940
  tableTo: string;
940
941
  columnsTo: string[];
941
- schemaTo: string;
942
942
  }>>;
943
943
  }, "strict", import("zod").ZodTypeAny, {
944
944
  name: string;
@@ -960,12 +960,12 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
960
960
  foreignKeys: Record<string, {
961
961
  onUpdate?: string | undefined;
962
962
  onDelete?: string | undefined;
963
+ schemaTo?: string | undefined;
963
964
  name: string;
964
965
  tableFrom: string;
965
966
  columnsFrom: string[];
966
967
  tableTo: string;
967
968
  columnsTo: string[];
968
- schemaTo: string;
969
969
  }>;
970
970
  }, {
971
971
  name: string;
@@ -987,12 +987,12 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
987
987
  foreignKeys: Record<string, {
988
988
  onUpdate?: string | undefined;
989
989
  onDelete?: string | undefined;
990
+ schemaTo?: string | undefined;
990
991
  name: string;
991
992
  tableFrom: string;
992
993
  columnsFrom: string[];
993
994
  tableTo: string;
994
995
  columnsTo: string[];
995
- schemaTo: string;
996
996
  }>;
997
997
  }>>;
998
998
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1028,12 +1028,12 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1028
1028
  foreignKeys: Record<string, {
1029
1029
  onUpdate?: string | undefined;
1030
1030
  onDelete?: string | undefined;
1031
+ schemaTo?: string | undefined;
1031
1032
  name: string;
1032
1033
  tableFrom: string;
1033
1034
  columnsFrom: string[];
1034
1035
  tableTo: string;
1035
1036
  columnsTo: string[];
1036
- schemaTo: string;
1037
1037
  }>;
1038
1038
  }>;
1039
1039
  enums: Record<string, {
@@ -1063,12 +1063,12 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1063
1063
  foreignKeys: Record<string, {
1064
1064
  onUpdate?: string | undefined;
1065
1065
  onDelete?: string | undefined;
1066
+ schemaTo?: string | undefined;
1066
1067
  name: string;
1067
1068
  tableFrom: string;
1068
1069
  columnsFrom: string[];
1069
1070
  tableTo: string;
1070
1071
  columnsTo: string[];
1071
- schemaTo: string;
1072
1072
  }>;
1073
1073
  }>;
1074
1074
  enums: Record<string, {
@@ -1128,28 +1128,28 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1128
1128
  tableFrom: import("zod").ZodString;
1129
1129
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1130
1130
  tableTo: import("zod").ZodString;
1131
- schemaTo: import("zod").ZodString;
1131
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
1132
1132
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1133
1133
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1134
1134
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1135
1135
  }, "strict", import("zod").ZodTypeAny, {
1136
1136
  onUpdate?: string | undefined;
1137
1137
  onDelete?: string | undefined;
1138
+ schemaTo?: string | undefined;
1138
1139
  name: string;
1139
1140
  tableFrom: string;
1140
1141
  columnsFrom: string[];
1141
1142
  tableTo: string;
1142
1143
  columnsTo: string[];
1143
- schemaTo: string;
1144
1144
  }, {
1145
1145
  onUpdate?: string | undefined;
1146
1146
  onDelete?: string | undefined;
1147
+ schemaTo?: string | undefined;
1147
1148
  name: string;
1148
1149
  tableFrom: string;
1149
1150
  columnsFrom: string[];
1150
1151
  tableTo: string;
1151
1152
  columnsTo: string[];
1152
- schemaTo: string;
1153
1153
  }>>;
1154
1154
  }, "strict", import("zod").ZodTypeAny, {
1155
1155
  name: string;
@@ -1171,12 +1171,12 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1171
1171
  foreignKeys: Record<string, {
1172
1172
  onUpdate?: string | undefined;
1173
1173
  onDelete?: string | undefined;
1174
+ schemaTo?: string | undefined;
1174
1175
  name: string;
1175
1176
  tableFrom: string;
1176
1177
  columnsFrom: string[];
1177
1178
  tableTo: string;
1178
1179
  columnsTo: string[];
1179
- schemaTo: string;
1180
1180
  }>;
1181
1181
  schema: string;
1182
1182
  }, {
@@ -1199,12 +1199,12 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1199
1199
  foreignKeys: Record<string, {
1200
1200
  onUpdate?: string | undefined;
1201
1201
  onDelete?: string | undefined;
1202
+ schemaTo?: string | undefined;
1202
1203
  name: string;
1203
1204
  tableFrom: string;
1204
1205
  columnsFrom: string[];
1205
1206
  tableTo: string;
1206
1207
  columnsTo: string[];
1207
- schemaTo: string;
1208
1208
  }>;
1209
1209
  schema: string;
1210
1210
  }>>;
@@ -1242,12 +1242,12 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1242
1242
  foreignKeys: Record<string, {
1243
1243
  onUpdate?: string | undefined;
1244
1244
  onDelete?: string | undefined;
1245
+ schemaTo?: string | undefined;
1245
1246
  name: string;
1246
1247
  tableFrom: string;
1247
1248
  columnsFrom: string[];
1248
1249
  tableTo: string;
1249
1250
  columnsTo: string[];
1250
- schemaTo: string;
1251
1251
  }>;
1252
1252
  schema: string;
1253
1253
  }>;
@@ -1279,12 +1279,12 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1279
1279
  foreignKeys: Record<string, {
1280
1280
  onUpdate?: string | undefined;
1281
1281
  onDelete?: string | undefined;
1282
+ schemaTo?: string | undefined;
1282
1283
  name: string;
1283
1284
  tableFrom: string;
1284
1285
  columnsFrom: string[];
1285
1286
  tableTo: string;
1286
1287
  columnsTo: string[];
1287
- schemaTo: string;
1288
1288
  }>;
1289
1289
  schema: string;
1290
1290
  }>;
@@ -1346,28 +1346,28 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1346
1346
  tableFrom: import("zod").ZodString;
1347
1347
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1348
1348
  tableTo: import("zod").ZodString;
1349
- schemaTo: import("zod").ZodString;
1349
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
1350
1350
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1351
1351
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1352
1352
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1353
1353
  }, "strict", import("zod").ZodTypeAny, {
1354
1354
  onUpdate?: string | undefined;
1355
1355
  onDelete?: string | undefined;
1356
+ schemaTo?: string | undefined;
1356
1357
  name: string;
1357
1358
  tableFrom: string;
1358
1359
  columnsFrom: string[];
1359
1360
  tableTo: string;
1360
1361
  columnsTo: string[];
1361
- schemaTo: string;
1362
1362
  }, {
1363
1363
  onUpdate?: string | undefined;
1364
1364
  onDelete?: string | undefined;
1365
+ schemaTo?: string | undefined;
1365
1366
  name: string;
1366
1367
  tableFrom: string;
1367
1368
  columnsFrom: string[];
1368
1369
  tableTo: string;
1369
1370
  columnsTo: string[];
1370
- schemaTo: string;
1371
1371
  }>>;
1372
1372
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1373
1373
  name: import("zod").ZodString;
@@ -1412,12 +1412,12 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1412
1412
  foreignKeys: Record<string, {
1413
1413
  onUpdate?: string | undefined;
1414
1414
  onDelete?: string | undefined;
1415
+ schemaTo?: string | undefined;
1415
1416
  name: string;
1416
1417
  tableFrom: string;
1417
1418
  columnsFrom: string[];
1418
1419
  tableTo: string;
1419
1420
  columnsTo: string[];
1420
- schemaTo: string;
1421
1421
  }>;
1422
1422
  schema: string;
1423
1423
  compositePrimaryKeys: Record<string, {
@@ -1454,12 +1454,12 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1454
1454
  foreignKeys: Record<string, {
1455
1455
  onUpdate?: string | undefined;
1456
1456
  onDelete?: string | undefined;
1457
+ schemaTo?: string | undefined;
1457
1458
  name: string;
1458
1459
  tableFrom: string;
1459
1460
  columnsFrom: string[];
1460
1461
  tableTo: string;
1461
1462
  columnsTo: string[];
1462
- schemaTo: string;
1463
1463
  }>;
1464
1464
  schema: string;
1465
1465
  compositePrimaryKeys: Record<string, {
@@ -1520,12 +1520,12 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1520
1520
  foreignKeys: Record<string, {
1521
1521
  onUpdate?: string | undefined;
1522
1522
  onDelete?: string | undefined;
1523
+ schemaTo?: string | undefined;
1523
1524
  name: string;
1524
1525
  tableFrom: string;
1525
1526
  columnsFrom: string[];
1526
1527
  tableTo: string;
1527
1528
  columnsTo: string[];
1528
- schemaTo: string;
1529
1529
  }>;
1530
1530
  schema: string;
1531
1531
  compositePrimaryKeys: Record<string, {
@@ -1578,12 +1578,12 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1578
1578
  foreignKeys: Record<string, {
1579
1579
  onUpdate?: string | undefined;
1580
1580
  onDelete?: string | undefined;
1581
+ schemaTo?: string | undefined;
1581
1582
  name: string;
1582
1583
  tableFrom: string;
1583
1584
  columnsFrom: string[];
1584
1585
  tableTo: string;
1585
1586
  columnsTo: string[];
1586
- schemaTo: string;
1587
1587
  }>;
1588
1588
  schema: string;
1589
1589
  compositePrimaryKeys: Record<string, {
@@ -1701,28 +1701,28 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1701
1701
  tableFrom: import("zod").ZodString;
1702
1702
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1703
1703
  tableTo: import("zod").ZodString;
1704
- schemaTo: import("zod").ZodString;
1704
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
1705
1705
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1706
1706
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1707
1707
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1708
1708
  }, "strict", import("zod").ZodTypeAny, {
1709
1709
  onUpdate?: string | undefined;
1710
1710
  onDelete?: string | undefined;
1711
+ schemaTo?: string | undefined;
1711
1712
  name: string;
1712
1713
  tableFrom: string;
1713
1714
  columnsFrom: string[];
1714
1715
  tableTo: string;
1715
1716
  columnsTo: string[];
1716
- schemaTo: string;
1717
1717
  }, {
1718
1718
  onUpdate?: string | undefined;
1719
1719
  onDelete?: string | undefined;
1720
+ schemaTo?: string | undefined;
1720
1721
  name: string;
1721
1722
  tableFrom: string;
1722
1723
  columnsFrom: string[];
1723
1724
  tableTo: string;
1724
1725
  columnsTo: string[];
1725
- schemaTo: string;
1726
1726
  }>>;
1727
1727
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1728
1728
  name: import("zod").ZodString;
@@ -1767,12 +1767,12 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1767
1767
  foreignKeys: Record<string, {
1768
1768
  onUpdate?: string | undefined;
1769
1769
  onDelete?: string | undefined;
1770
+ schemaTo?: string | undefined;
1770
1771
  name: string;
1771
1772
  tableFrom: string;
1772
1773
  columnsFrom: string[];
1773
1774
  tableTo: string;
1774
1775
  columnsTo: string[];
1775
- schemaTo: string;
1776
1776
  }>;
1777
1777
  schema: string;
1778
1778
  compositePrimaryKeys: Record<string, {
@@ -1809,12 +1809,12 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1809
1809
  foreignKeys: Record<string, {
1810
1810
  onUpdate?: string | undefined;
1811
1811
  onDelete?: string | undefined;
1812
+ schemaTo?: string | undefined;
1812
1813
  name: string;
1813
1814
  tableFrom: string;
1814
1815
  columnsFrom: string[];
1815
1816
  tableTo: string;
1816
1817
  columnsTo: string[];
1817
- schemaTo: string;
1818
1818
  }>;
1819
1819
  schema: string;
1820
1820
  compositePrimaryKeys: Record<string, {
@@ -1923,12 +1923,12 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1923
1923
  foreignKeys: Record<string, {
1924
1924
  onUpdate?: string | undefined;
1925
1925
  onDelete?: string | undefined;
1926
+ schemaTo?: string | undefined;
1926
1927
  name: string;
1927
1928
  tableFrom: string;
1928
1929
  columnsFrom: string[];
1929
1930
  tableTo: string;
1930
1931
  columnsTo: string[];
1931
- schemaTo: string;
1932
1932
  }>;
1933
1933
  schema: string;
1934
1934
  compositePrimaryKeys: Record<string, {
@@ -1988,12 +1988,12 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
1988
1988
  foreignKeys: Record<string, {
1989
1989
  onUpdate?: string | undefined;
1990
1990
  onDelete?: string | undefined;
1991
+ schemaTo?: string | undefined;
1991
1992
  name: string;
1992
1993
  tableFrom: string;
1993
1994
  columnsFrom: string[];
1994
1995
  tableTo: string;
1995
1996
  columnsTo: string[];
1996
- schemaTo: string;
1997
1997
  }>;
1998
1998
  schema: string;
1999
1999
  compositePrimaryKeys: Record<string, {
@@ -2327,28 +2327,28 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2327
2327
  tableFrom: import("zod").ZodString;
2328
2328
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2329
2329
  tableTo: import("zod").ZodString;
2330
- schemaTo: import("zod").ZodString;
2330
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
2331
2331
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2332
2332
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2333
2333
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2334
2334
  }, "strict", import("zod").ZodTypeAny, {
2335
2335
  onUpdate?: string | undefined;
2336
2336
  onDelete?: string | undefined;
2337
+ schemaTo?: string | undefined;
2337
2338
  name: string;
2338
2339
  tableFrom: string;
2339
2340
  columnsFrom: string[];
2340
2341
  tableTo: string;
2341
2342
  columnsTo: string[];
2342
- schemaTo: string;
2343
2343
  }, {
2344
2344
  onUpdate?: string | undefined;
2345
2345
  onDelete?: string | undefined;
2346
+ schemaTo?: string | undefined;
2346
2347
  name: string;
2347
2348
  tableFrom: string;
2348
2349
  columnsFrom: string[];
2349
2350
  tableTo: string;
2350
2351
  columnsTo: string[];
2351
- schemaTo: string;
2352
2352
  }>>;
2353
2353
  }, "strict", import("zod").ZodTypeAny, {
2354
2354
  name: string;
@@ -2370,12 +2370,12 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2370
2370
  foreignKeys: Record<string, {
2371
2371
  onUpdate?: string | undefined;
2372
2372
  onDelete?: string | undefined;
2373
+ schemaTo?: string | undefined;
2373
2374
  name: string;
2374
2375
  tableFrom: string;
2375
2376
  columnsFrom: string[];
2376
2377
  tableTo: string;
2377
2378
  columnsTo: string[];
2378
- schemaTo: string;
2379
2379
  }>;
2380
2380
  }, {
2381
2381
  name: string;
@@ -2397,12 +2397,12 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2397
2397
  foreignKeys: Record<string, {
2398
2398
  onUpdate?: string | undefined;
2399
2399
  onDelete?: string | undefined;
2400
+ schemaTo?: string | undefined;
2400
2401
  name: string;
2401
2402
  tableFrom: string;
2402
2403
  columnsFrom: string[];
2403
2404
  tableTo: string;
2404
2405
  columnsTo: string[];
2405
- schemaTo: string;
2406
2406
  }>;
2407
2407
  }>>;
2408
2408
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2443,12 +2443,12 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2443
2443
  foreignKeys: Record<string, {
2444
2444
  onUpdate?: string | undefined;
2445
2445
  onDelete?: string | undefined;
2446
+ schemaTo?: string | undefined;
2446
2447
  name: string;
2447
2448
  tableFrom: string;
2448
2449
  columnsFrom: string[];
2449
2450
  tableTo: string;
2450
2451
  columnsTo: string[];
2451
- schemaTo: string;
2452
2452
  }>;
2453
2453
  }>;
2454
2454
  enums: Record<string, {
@@ -2480,12 +2480,12 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2480
2480
  foreignKeys: Record<string, {
2481
2481
  onUpdate?: string | undefined;
2482
2482
  onDelete?: string | undefined;
2483
+ schemaTo?: string | undefined;
2483
2484
  name: string;
2484
2485
  tableFrom: string;
2485
2486
  columnsFrom: string[];
2486
2487
  tableTo: string;
2487
2488
  columnsTo: string[];
2488
- schemaTo: string;
2489
2489
  }>;
2490
2490
  }>;
2491
2491
  enums: Record<string, {
@@ -2545,28 +2545,28 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2545
2545
  tableFrom: import("zod").ZodString;
2546
2546
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2547
2547
  tableTo: import("zod").ZodString;
2548
- schemaTo: import("zod").ZodString;
2548
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
2549
2549
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2550
2550
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2551
2551
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2552
2552
  }, "strict", import("zod").ZodTypeAny, {
2553
2553
  onUpdate?: string | undefined;
2554
2554
  onDelete?: string | undefined;
2555
+ schemaTo?: string | undefined;
2555
2556
  name: string;
2556
2557
  tableFrom: string;
2557
2558
  columnsFrom: string[];
2558
2559
  tableTo: string;
2559
2560
  columnsTo: string[];
2560
- schemaTo: string;
2561
2561
  }, {
2562
2562
  onUpdate?: string | undefined;
2563
2563
  onDelete?: string | undefined;
2564
+ schemaTo?: string | undefined;
2564
2565
  name: string;
2565
2566
  tableFrom: string;
2566
2567
  columnsFrom: string[];
2567
2568
  tableTo: string;
2568
2569
  columnsTo: string[];
2569
- schemaTo: string;
2570
2570
  }>>;
2571
2571
  }, "strict", import("zod").ZodTypeAny, {
2572
2572
  name: string;
@@ -2588,12 +2588,12 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2588
2588
  foreignKeys: Record<string, {
2589
2589
  onUpdate?: string | undefined;
2590
2590
  onDelete?: string | undefined;
2591
+ schemaTo?: string | undefined;
2591
2592
  name: string;
2592
2593
  tableFrom: string;
2593
2594
  columnsFrom: string[];
2594
2595
  tableTo: string;
2595
2596
  columnsTo: string[];
2596
- schemaTo: string;
2597
2597
  }>;
2598
2598
  schema: string;
2599
2599
  }, {
@@ -2616,12 +2616,12 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2616
2616
  foreignKeys: Record<string, {
2617
2617
  onUpdate?: string | undefined;
2618
2618
  onDelete?: string | undefined;
2619
+ schemaTo?: string | undefined;
2619
2620
  name: string;
2620
2621
  tableFrom: string;
2621
2622
  columnsFrom: string[];
2622
2623
  tableTo: string;
2623
2624
  columnsTo: string[];
2624
- schemaTo: string;
2625
2625
  }>;
2626
2626
  schema: string;
2627
2627
  }>>;
@@ -2664,12 +2664,12 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2664
2664
  foreignKeys: Record<string, {
2665
2665
  onUpdate?: string | undefined;
2666
2666
  onDelete?: string | undefined;
2667
+ schemaTo?: string | undefined;
2667
2668
  name: string;
2668
2669
  tableFrom: string;
2669
2670
  columnsFrom: string[];
2670
2671
  tableTo: string;
2671
2672
  columnsTo: string[];
2672
- schemaTo: string;
2673
2673
  }>;
2674
2674
  schema: string;
2675
2675
  }>;
@@ -2703,12 +2703,12 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2703
2703
  foreignKeys: Record<string, {
2704
2704
  onUpdate?: string | undefined;
2705
2705
  onDelete?: string | undefined;
2706
+ schemaTo?: string | undefined;
2706
2707
  name: string;
2707
2708
  tableFrom: string;
2708
2709
  columnsFrom: string[];
2709
2710
  tableTo: string;
2710
2711
  columnsTo: string[];
2711
- schemaTo: string;
2712
2712
  }>;
2713
2713
  schema: string;
2714
2714
  }>;
@@ -2770,28 +2770,28 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
2770
2770
  tableFrom: import("zod").ZodString;
2771
2771
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2772
2772
  tableTo: import("zod").ZodString;
2773
- schemaTo: import("zod").ZodString;
2773
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
2774
2774
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2775
2775
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2776
2776
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2777
2777
  }, "strict", import("zod").ZodTypeAny, {
2778
2778
  onUpdate?: string | undefined;
2779
2779
  onDelete?: string | undefined;
2780
+ schemaTo?: string | undefined;
2780
2781
  name: string;
2781
2782
  tableFrom: string;
2782
2783
  columnsFrom: string[];
2783
2784
  tableTo: string;
2784
2785
  columnsTo: string[];
2785
- schemaTo: string;
2786
2786
  }, {
2787
2787
  onUpdate?: string | undefined;
2788
2788
  onDelete?: string | undefined;
2789
+ schemaTo?: string | undefined;
2789
2790
  name: string;
2790
2791
  tableFrom: string;
2791
2792
  columnsFrom: string[];
2792
2793
  tableTo: string;
2793
2794
  columnsTo: string[];
2794
- schemaTo: string;
2795
2795
  }>>;
2796
2796
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2797
2797
  name: import("zod").ZodString;
@@ -2836,12 +2836,12 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
2836
2836
  foreignKeys: Record<string, {
2837
2837
  onUpdate?: string | undefined;
2838
2838
  onDelete?: string | undefined;
2839
+ schemaTo?: string | undefined;
2839
2840
  name: string;
2840
2841
  tableFrom: string;
2841
2842
  columnsFrom: string[];
2842
2843
  tableTo: string;
2843
2844
  columnsTo: string[];
2844
- schemaTo: string;
2845
2845
  }>;
2846
2846
  schema: string;
2847
2847
  compositePrimaryKeys: Record<string, {
@@ -2878,12 +2878,12 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
2878
2878
  foreignKeys: Record<string, {
2879
2879
  onUpdate?: string | undefined;
2880
2880
  onDelete?: string | undefined;
2881
+ schemaTo?: string | undefined;
2881
2882
  name: string;
2882
2883
  tableFrom: string;
2883
2884
  columnsFrom: string[];
2884
2885
  tableTo: string;
2885
2886
  columnsTo: string[];
2886
- schemaTo: string;
2887
2887
  }>;
2888
2888
  schema: string;
2889
2889
  compositePrimaryKeys: Record<string, {
@@ -2997,12 +2997,12 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
2997
2997
  foreignKeys: Record<string, {
2998
2998
  onUpdate?: string | undefined;
2999
2999
  onDelete?: string | undefined;
3000
+ schemaTo?: string | undefined;
3000
3001
  name: string;
3001
3002
  tableFrom: string;
3002
3003
  columnsFrom: string[];
3003
3004
  tableTo: string;
3004
3005
  columnsTo: string[];
3005
- schemaTo: string;
3006
3006
  }>;
3007
3007
  schema: string;
3008
3008
  compositePrimaryKeys: Record<string, {
@@ -3064,12 +3064,12 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3064
3064
  foreignKeys: Record<string, {
3065
3065
  onUpdate?: string | undefined;
3066
3066
  onDelete?: string | undefined;
3067
+ schemaTo?: string | undefined;
3067
3068
  name: string;
3068
3069
  tableFrom: string;
3069
3070
  columnsFrom: string[];
3070
3071
  tableTo: string;
3071
3072
  columnsTo: string[];
3072
- schemaTo: string;
3073
3073
  }>;
3074
3074
  schema: string;
3075
3075
  compositePrimaryKeys: Record<string, {
@@ -3496,28 +3496,28 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3496
3496
  tableFrom: import("zod").ZodString;
3497
3497
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3498
3498
  tableTo: import("zod").ZodString;
3499
- schemaTo: import("zod").ZodString;
3499
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
3500
3500
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3501
3501
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3502
3502
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3503
3503
  }, "strict", import("zod").ZodTypeAny, {
3504
3504
  onUpdate?: string | undefined;
3505
3505
  onDelete?: string | undefined;
3506
+ schemaTo?: string | undefined;
3506
3507
  name: string;
3507
3508
  tableFrom: string;
3508
3509
  columnsFrom: string[];
3509
3510
  tableTo: string;
3510
3511
  columnsTo: string[];
3511
- schemaTo: string;
3512
3512
  }, {
3513
3513
  onUpdate?: string | undefined;
3514
3514
  onDelete?: string | undefined;
3515
+ schemaTo?: string | undefined;
3515
3516
  name: string;
3516
3517
  tableFrom: string;
3517
3518
  columnsFrom: string[];
3518
3519
  tableTo: string;
3519
3520
  columnsTo: string[];
3520
- schemaTo: string;
3521
3521
  }>>;
3522
3522
  }, "strict", import("zod").ZodTypeAny, {
3523
3523
  name: string;
@@ -3539,12 +3539,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3539
3539
  foreignKeys: Record<string, {
3540
3540
  onUpdate?: string | undefined;
3541
3541
  onDelete?: string | undefined;
3542
+ schemaTo?: string | undefined;
3542
3543
  name: string;
3543
3544
  tableFrom: string;
3544
3545
  columnsFrom: string[];
3545
3546
  tableTo: string;
3546
3547
  columnsTo: string[];
3547
- schemaTo: string;
3548
3548
  }>;
3549
3549
  }, {
3550
3550
  name: string;
@@ -3566,12 +3566,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3566
3566
  foreignKeys: Record<string, {
3567
3567
  onUpdate?: string | undefined;
3568
3568
  onDelete?: string | undefined;
3569
+ schemaTo?: string | undefined;
3569
3570
  name: string;
3570
3571
  tableFrom: string;
3571
3572
  columnsFrom: string[];
3572
3573
  tableTo: string;
3573
3574
  columnsTo: string[];
3574
- schemaTo: string;
3575
3575
  }>;
3576
3576
  }>>;
3577
3577
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3612,12 +3612,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3612
3612
  foreignKeys: Record<string, {
3613
3613
  onUpdate?: string | undefined;
3614
3614
  onDelete?: string | undefined;
3615
+ schemaTo?: string | undefined;
3615
3616
  name: string;
3616
3617
  tableFrom: string;
3617
3618
  columnsFrom: string[];
3618
3619
  tableTo: string;
3619
3620
  columnsTo: string[];
3620
- schemaTo: string;
3621
3621
  }>;
3622
3622
  }>;
3623
3623
  enums: Record<string, {
@@ -3649,12 +3649,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3649
3649
  foreignKeys: Record<string, {
3650
3650
  onUpdate?: string | undefined;
3651
3651
  onDelete?: string | undefined;
3652
+ schemaTo?: string | undefined;
3652
3653
  name: string;
3653
3654
  tableFrom: string;
3654
3655
  columnsFrom: string[];
3655
3656
  tableTo: string;
3656
3657
  columnsTo: string[];
3657
- schemaTo: string;
3658
3658
  }>;
3659
3659
  }>;
3660
3660
  enums: Record<string, {
@@ -3713,28 +3713,28 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3713
3713
  tableFrom: import("zod").ZodString;
3714
3714
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3715
3715
  tableTo: import("zod").ZodString;
3716
- schemaTo: import("zod").ZodString;
3716
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
3717
3717
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3718
3718
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3719
3719
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3720
3720
  }, "strict", import("zod").ZodTypeAny, {
3721
3721
  onUpdate?: string | undefined;
3722
3722
  onDelete?: string | undefined;
3723
+ schemaTo?: string | undefined;
3723
3724
  name: string;
3724
3725
  tableFrom: string;
3725
3726
  columnsFrom: string[];
3726
3727
  tableTo: string;
3727
3728
  columnsTo: string[];
3728
- schemaTo: string;
3729
3729
  }, {
3730
3730
  onUpdate?: string | undefined;
3731
3731
  onDelete?: string | undefined;
3732
+ schemaTo?: string | undefined;
3732
3733
  name: string;
3733
3734
  tableFrom: string;
3734
3735
  columnsFrom: string[];
3735
3736
  tableTo: string;
3736
3737
  columnsTo: string[];
3737
- schemaTo: string;
3738
3738
  }>>;
3739
3739
  }, "strict", import("zod").ZodTypeAny, {
3740
3740
  name: string;
@@ -3756,12 +3756,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3756
3756
  foreignKeys: Record<string, {
3757
3757
  onUpdate?: string | undefined;
3758
3758
  onDelete?: string | undefined;
3759
+ schemaTo?: string | undefined;
3759
3760
  name: string;
3760
3761
  tableFrom: string;
3761
3762
  columnsFrom: string[];
3762
3763
  tableTo: string;
3763
3764
  columnsTo: string[];
3764
- schemaTo: string;
3765
3765
  }>;
3766
3766
  schema: string;
3767
3767
  }, {
@@ -3784,12 +3784,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3784
3784
  foreignKeys: Record<string, {
3785
3785
  onUpdate?: string | undefined;
3786
3786
  onDelete?: string | undefined;
3787
+ schemaTo?: string | undefined;
3787
3788
  name: string;
3788
3789
  tableFrom: string;
3789
3790
  columnsFrom: string[];
3790
3791
  tableTo: string;
3791
3792
  columnsTo: string[];
3792
- schemaTo: string;
3793
3793
  }>;
3794
3794
  schema: string;
3795
3795
  }>>;
@@ -3832,12 +3832,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3832
3832
  foreignKeys: Record<string, {
3833
3833
  onUpdate?: string | undefined;
3834
3834
  onDelete?: string | undefined;
3835
+ schemaTo?: string | undefined;
3835
3836
  name: string;
3836
3837
  tableFrom: string;
3837
3838
  columnsFrom: string[];
3838
3839
  tableTo: string;
3839
3840
  columnsTo: string[];
3840
- schemaTo: string;
3841
3841
  }>;
3842
3842
  schema: string;
3843
3843
  }>;
@@ -3871,12 +3871,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3871
3871
  foreignKeys: Record<string, {
3872
3872
  onUpdate?: string | undefined;
3873
3873
  onDelete?: string | undefined;
3874
+ schemaTo?: string | undefined;
3874
3875
  name: string;
3875
3876
  tableFrom: string;
3876
3877
  columnsFrom: string[];
3877
3878
  tableTo: string;
3878
3879
  columnsTo: string[];
3879
- schemaTo: string;
3880
3880
  }>;
3881
3881
  schema: string;
3882
3882
  }>;
@@ -3937,28 +3937,28 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3937
3937
  tableFrom: import("zod").ZodString;
3938
3938
  columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3939
3939
  tableTo: import("zod").ZodString;
3940
- schemaTo: import("zod").ZodString;
3940
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
3941
3941
  columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3942
3942
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3943
3943
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3944
3944
  }, "strict", import("zod").ZodTypeAny, {
3945
3945
  onUpdate?: string | undefined;
3946
3946
  onDelete?: string | undefined;
3947
+ schemaTo?: string | undefined;
3947
3948
  name: string;
3948
3949
  tableFrom: string;
3949
3950
  columnsFrom: string[];
3950
3951
  tableTo: string;
3951
3952
  columnsTo: string[];
3952
- schemaTo: string;
3953
3953
  }, {
3954
3954
  onUpdate?: string | undefined;
3955
3955
  onDelete?: string | undefined;
3956
+ schemaTo?: string | undefined;
3956
3957
  name: string;
3957
3958
  tableFrom: string;
3958
3959
  columnsFrom: string[];
3959
3960
  tableTo: string;
3960
3961
  columnsTo: string[];
3961
- schemaTo: string;
3962
3962
  }>>;
3963
3963
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3964
3964
  name: import("zod").ZodString;
@@ -4003,12 +4003,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4003
4003
  foreignKeys: Record<string, {
4004
4004
  onUpdate?: string | undefined;
4005
4005
  onDelete?: string | undefined;
4006
+ schemaTo?: string | undefined;
4006
4007
  name: string;
4007
4008
  tableFrom: string;
4008
4009
  columnsFrom: string[];
4009
4010
  tableTo: string;
4010
4011
  columnsTo: string[];
4011
- schemaTo: string;
4012
4012
  }>;
4013
4013
  schema: string;
4014
4014
  compositePrimaryKeys: Record<string, {
@@ -4045,12 +4045,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4045
4045
  foreignKeys: Record<string, {
4046
4046
  onUpdate?: string | undefined;
4047
4047
  onDelete?: string | undefined;
4048
+ schemaTo?: string | undefined;
4048
4049
  name: string;
4049
4050
  tableFrom: string;
4050
4051
  columnsFrom: string[];
4051
4052
  tableTo: string;
4052
4053
  columnsTo: string[];
4053
- schemaTo: string;
4054
4054
  }>;
4055
4055
  schema: string;
4056
4056
  compositePrimaryKeys: Record<string, {
@@ -4164,12 +4164,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4164
4164
  foreignKeys: Record<string, {
4165
4165
  onUpdate?: string | undefined;
4166
4166
  onDelete?: string | undefined;
4167
+ schemaTo?: string | undefined;
4167
4168
  name: string;
4168
4169
  tableFrom: string;
4169
4170
  columnsFrom: string[];
4170
4171
  tableTo: string;
4171
4172
  columnsTo: string[];
4172
- schemaTo: string;
4173
4173
  }>;
4174
4174
  schema: string;
4175
4175
  compositePrimaryKeys: Record<string, {
@@ -4231,12 +4231,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4231
4231
  foreignKeys: Record<string, {
4232
4232
  onUpdate?: string | undefined;
4233
4233
  onDelete?: string | undefined;
4234
+ schemaTo?: string | undefined;
4234
4235
  name: string;
4235
4236
  tableFrom: string;
4236
4237
  columnsFrom: string[];
4237
4238
  tableTo: string;
4238
4239
  columnsTo: string[];
4239
- schemaTo: string;
4240
4240
  }>;
4241
4241
  schema: string;
4242
4242
  compositePrimaryKeys: Record<string, {
@@ -4301,12 +4301,12 @@ export declare const dryPg: {
4301
4301
  foreignKeys: Record<string, {
4302
4302
  onUpdate?: string | undefined;
4303
4303
  onDelete?: string | undefined;
4304
+ schemaTo?: string | undefined;
4304
4305
  name: string;
4305
4306
  tableFrom: string;
4306
4307
  columnsFrom: string[];
4307
4308
  tableTo: string;
4308
4309
  columnsTo: string[];
4309
- schemaTo: string;
4310
4310
  }>;
4311
4311
  schema: string;
4312
4312
  compositePrimaryKeys: Record<string, {
package/utils.d.ts CHANGED
@@ -101,12 +101,12 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
101
101
  foreignKeys: Record<string, {
102
102
  onUpdate?: string | undefined;
103
103
  onDelete?: string | undefined;
104
+ schemaTo?: string | undefined;
104
105
  name: string;
105
106
  tableFrom: string;
106
107
  columnsFrom: string[];
107
108
  tableTo: string;
108
109
  columnsTo: string[];
109
- schemaTo: string;
110
110
  }>;
111
111
  schema: string;
112
112
  compositePrimaryKeys: Record<string, {
@@ -164,12 +164,12 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
164
164
  foreignKeys: Record<string, {
165
165
  onUpdate?: string | undefined;
166
166
  onDelete?: string | undefined;
167
+ schemaTo?: string | undefined;
167
168
  name: string;
168
169
  tableFrom: string;
169
170
  columnsFrom: string[];
170
171
  tableTo: string;
171
172
  columnsTo: string[];
172
- schemaTo: string;
173
173
  }>;
174
174
  schema: string;
175
175
  compositePrimaryKeys: Record<string, {
package/utils.js CHANGED
@@ -4817,7 +4817,7 @@ var init_pgSchema = __esm({
4817
4817
  tableFrom: stringType(),
4818
4818
  columnsFrom: stringType().array(),
4819
4819
  tableTo: stringType(),
4820
- schemaTo: stringType(),
4820
+ schemaTo: stringType().optional(),
4821
4821
  columnsTo: stringType().array(),
4822
4822
  onUpdate: stringType().optional(),
4823
4823
  onDelete: stringType().optional()
@@ -12048,7 +12048,7 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
12048
12048
  name,
12049
12049
  tableFrom,
12050
12050
  tableTo,
12051
- schemaTo,
12051
+ schemaTo: schemaTo ?? "public",
12052
12052
  columnsFrom,
12053
12053
  columnsTo,
12054
12054
  onDelete,
@@ -15903,7 +15903,7 @@ ${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT ${statement.newCo
15903
15903
  const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(",");
15904
15904
  const toColumnsString = columnsTo.map((it) => `"${it}"`).join(",");
15905
15905
  const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${tableFrom}"` : `"${tableFrom}"`;
15906
- const tableToNameWithSchema = statement.schema ? `"${schemaTo}"."${tableTo}"` : `"${tableTo}"`;
15906
+ const tableToNameWithSchema = schemaTo ? `"${schemaTo}"."${tableTo}"` : `"${tableTo}"`;
15907
15907
  const alterStatement = `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement}`;
15908
15908
  let sql2 = "DO $$ BEGIN\n";
15909
15909
  sql2 += " " + alterStatement + ";\n";
@@ -15962,8 +15962,9 @@ ${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT ${statement.newCo
15962
15962
  const onUpdateStatement = newFk.onUpdate ? ` ON UPDATE ${newFk.onUpdate}` : "";
15963
15963
  const fromColumnsString = newFk.columnsFrom.map((it) => `"${it}"`).join(",");
15964
15964
  const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(",");
15965
- const tableFromNameWithSchema = statement.schema ? `"${statement.schema}"."${newFk.tableFrom}"` : `"${newFk.tableFrom}"`;
15966
- const alterStatement = `ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES "${newFk.tableTo}"(${toColumnsString})${onDeleteStatement}${onUpdateStatement}`;
15965
+ const tableFromNameWithSchema = oldFk.schemaTo ? `"${oldFk.schemaTo}"."${oldFk.tableFrom}"` : `"${oldFk.tableFrom}"`;
15966
+ const tableToNameWithSchema = newFk.schemaTo ? `"${newFk.schemaTo}"."${newFk.tableFrom}"` : `"${newFk.tableFrom}"`;
15967
+ const alterStatement = `ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement}`;
15967
15968
  sql2 += "DO $$ BEGIN\n";
15968
15969
  sql2 += " " + alterStatement + ";\n";
15969
15970
  sql2 += "EXCEPTION\n";