@axium/server 0.36.5 → 0.37.0

package/dist/db/schema.d.ts

@@ -0,0 +1,268 @@
+import type { Expand, MutableRecursive, ReadonlyRecursive } from 'utilium';
+import * as z from 'zod';
+import raw from './schema.json';
+import { Table, type Column, type TableValue } from './data.js';
+import * as delta from './delta.js';
+export * from './data.js';
+export declare const SchemaDecl: z.ZodObject<{
+    tables: z.ZodRecord<z.ZodString, z.ZodObject<{
+        columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            primary: z.ZodDefault<z.ZodBoolean>;
+            references: z.ZodOptional<z.ZodString>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            default: z.ZodOptional<z.ZodAny>;
+            check: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"primary_key">;
+            on: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"foreign_key">;
+            on: z.ZodArray<z.ZodString>;
+            target: z.ZodString;
+            references: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"unique">;
+            on: z.ZodArray<z.ZodString>;
+            nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"check">;
+            check: z.ZodString;
+        }, z.core.$strict>], "type">>>>;
+    }, z.core.$strict>>;
+    indexes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        on: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export interface SchemaDecl extends z.infer<typeof SchemaDecl> {
+}
+export declare const SchemaFile: z.ZodObject<{
+    format: z.ZodLiteral<1>;
+    versions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        tables: z.ZodRecord<z.ZodString, z.ZodObject<{
+            columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                primary: z.ZodDefault<z.ZodBoolean>;
+                references: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                default: z.ZodOptional<z.ZodAny>;
+                check: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"primary_key">;
+                on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"foreign_key">;
+                on: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"unique">;
+                on: z.ZodArray<z.ZodString>;
+                nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"check">;
+                check: z.ZodString;
+            }, z.core.$strict>], "type">>>>;
+        }, z.core.$strict>>;
+        indexes: z.ZodRecord<z.ZodString, z.ZodObject<{
+            on: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        delta: z.ZodLiteral<false>;
+    }, z.core.$strict>, z.ZodObject<{
+        delta: z.ZodLiteral<true>;
+        add_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            columns: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                primary: z.ZodDefault<z.ZodBoolean>;
+                references: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                default: z.ZodOptional<z.ZodAny>;
+                check: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"primary_key">;
+                on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"foreign_key">;
+                on: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"unique">;
+                on: z.ZodArray<z.ZodString>;
+                nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"check">;
+                check: z.ZodString;
+            }, z.core.$strict>], "type">>>>;
+        }, z.core.$strict>>>>;
+        drop_tables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        alter_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            add_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                primary: z.ZodDefault<z.ZodBoolean>;
+                references: z.ZodOptional<z.ZodString>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                default: z.ZodOptional<z.ZodAny>;
+                check: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+            drop_columns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            alter_columns: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"bigint" | "boolean" | "uuid" | "date" | "binary" | "integer" | "int2" | "int4" | "int8" | "smallint" | "real" | "double precision" | "float4" | "float8" | "decimal" | "numeric" | "serial" | "bigserial" | "bool" | "varchar" | "char" | "text" | "datetime" | "time" | "timetz" | "timestamp" | "timestamptz" | "bytea" | "varbinary" | "blob" | "int4range" | "numrange" | "tsrange" | "tstzrange" | "daterange" | "int4multirange" | "int8multirange" | "nummultirange" | "tsmultirange" | "tstzmultirange" | "datemultirange" | "json" | "jsonb">, z.ZodTemplateLiteral<`binary(${number})` | `varchar(${number})` | `char(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`>, z.ZodTemplateLiteral<`decimal(${number},${number})` | `decimal(${number}, ${number})` | `numeric(${number},${number})` | `numeric(${number}, ${number})`>]>, z.ZodTemplateLiteral<"bigint[]" | "boolean[]" | "uuid[]" | "date[]" | "binary[]" | "integer[]" | "int2[]" | "int4[]" | "int8[]" | "smallint[]" | "real[]" | "double precision[]" | "float4[]" | "float8[]" | "decimal[]" | "numeric[]" | "serial[]" | "bigserial[]" | "bool[]" | "varchar[]" | "char[]" | "text[]" | "datetime[]" | "time[]" | "timetz[]" | "timestamp[]" | "timestamptz[]" | "bytea[]" | "varbinary[]" | "blob[]" | "int4range[]" | "numrange[]" | "tsrange[]" | "tstzrange[]" | "daterange[]" | "int4multirange[]" | "int8multirange[]" | "nummultirange[]" | "tsmultirange[]" | "tstzmultirange[]" | "datemultirange[]" | "json[]" | "jsonb[]" | `binary(${number})[]` | `varchar(${number})[]` | `char(${number})[]` | `datetime(${number})[]` | `time(${number})[]` | `timetz(${number})[]` | `timestamp(${number})[]` | `timestamptz(${number})[]` | `varbinary(${number})[]` | `decimal(${number},${number})[]` | `decimal(${number}, ${number})[]` | `numeric(${number},${number})[]` | `numeric(${number}, ${number})[]` | `bigint[${number}]` | `boolean[${number}]` | `uuid[${number}]` | `date[${number}]` | `binary[${number}]` | `integer[${number}]` | `int2[${number}]` | `int4[${number}]` | `int8[${number}]` | `smallint[${number}]` | `real[${number}]` | `double precision[${number}]` | `float4[${number}]` | `float8[${number}]` | `decimal[${number}]` | `numeric[${number}]` | `serial[${number}]` | `bigserial[${number}]` | `bool[${number}]` | `varchar[${number}]` | `char[${number}]` | `text[${number}]` | `datetime[${number}]` | `time[${number}]` | `timetz[${number}]` | `timestamp[${number}]` | `timestamptz[${number}]` | `bytea[${number}]` | `varbinary[${number}]` | `blob[${number}]` | `int4range[${number}]` | `numrange[${number}]` | `tsrange[${number}]` | `tstzrange[${number}]` | `daterange[${number}]` | `int4multirange[${number}]` | `int8multirange[${number}]` | `nummultirange[${number}]` | `tsmultirange[${number}]` | `tstzmultirange[${number}]` | `datemultirange[${number}]` | `json[${number}]` | `jsonb[${number}]` | `binary(${number})[${number}]` | `varchar(${number})[${number}]` | `char(${number})[${number}]` | `datetime(${number})[${number}]` | `time(${number})[${number}]` | `timetz(${number})[${number}]` | `timestamp(${number})[${number}]` | `timestamptz(${number})[${number}]` | `varbinary(${number})[${number}]` | `decimal(${number},${number})[${number}]` | `decimal(${number}, ${number})[${number}]` | `numeric(${number},${number})[${number}]` | `numeric(${number}, ${number})[${number}]`>]>>;
+                default: z.ZodOptional<z.ZodString>;
+                ops: z.ZodOptional<z.ZodArray<z.ZodLiteral<"drop_default" | "set_required" | "drop_required">>>;
+            }, z.core.$strict>>>>;
+            add_constraints: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"primary_key">;
+                on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"foreign_key">;
+                on: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"unique">;
+                on: z.ZodArray<z.ZodString>;
+                nulls_not_distinct: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"check">;
+                check: z.ZodString;
+            }, z.core.$strict>], "type">>>>;
+            drop_constraints: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>>>;
+        add_indexes: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            on: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>>;
+        drop_indexes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>], "delta">>;
+    wipe: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    latest: z.ZodOptional<z.ZodInt32>;
+    acl_tables: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strip>;
+export interface SchemaFile extends z.infer<typeof SchemaFile> {
+}
+export declare function getFiles(): Generator<[string, SchemaFile]>;
+export type ApplyColumnDelta<C extends z.input<typeof Column>, D extends z.input<typeof delta.Column>> = Omit<C, 'type' | 'default' | 'required'> & {
+    type: D extends {
+        type: infer T;
+    } ? T : C['type'];
+    default: D extends {
+        ops: readonly any[];
+    } ? 'drop_default' extends D['ops'][number] ? undefined : D extends {
+        default: infer Def;
+    } ? Def : C['default'] : D extends {
+        default: infer Def;
+    } ? Def : C['default'];
+    required: D extends {
+        ops: readonly any[];
+    } ? 'set_required' extends D['ops'][number] ? true : 'drop_required' extends D['ops'][number] ? false : C['required'] : C['required'];
+};
+export type ApplyTableDelta<T extends z.input<typeof Table>, D extends z.input<typeof delta.Table>> = {
+    columns: {
+        [K in keyof T['columns'] as K extends (D extends {
+            drop_columns: any[];
+        } ? D['drop_columns'][number] : never) ? never : K]: K extends keyof (D extends {
+            alter_columns: any;
+        } ? D['alter_columns'] : {}) ? ApplyColumnDelta<T['columns'][K], (D['alter_columns'] & {})[K & keyof D['alter_columns']]> : T['columns'][K];
+    } & (D extends {
+        add_columns: infer A;
+    } ? A : {});
+    constraints: {
+        [K in keyof T['constraints'] as K extends (D extends {
+            drop_constraints: any[];
+        } ? D['drop_constraints'][number] : never) ? never : K]: T['constraints'][K];
+    } & (D extends {
+        add_constraints: infer A;
+    } ? A : {});
+};
+export type ApplySchemaDelta<S extends z.input<typeof SchemaDecl>, D extends z.input<typeof delta.Version>> = {
+    tables: {
+        [K in keyof S['tables'] as K extends (D extends {
+            drop_tables: any[];
+        } ? D['drop_tables'][number] : never) ? never : K]: K extends keyof (D extends {
+            alter_tables: any;
+        } ? D['alter_tables'] : {}) ? ApplyTableDelta<S['tables'][K], (D['alter_tables'] & {})[K & keyof D['alter_tables']]> : S['tables'][K];
+    } & (D extends {
+        add_tables: infer A;
+    } ? A : {});
+    indexes: {
+        [K in keyof S['indexes'] as K extends (D extends {
+            drop_indexes: any[];
+        } ? D['drop_indexes'][number] : never) ? never : K]: S['indexes'][K];
+    };
+};
+type ResolveVersions<V extends readonly any[], Current extends z.input<typeof SchemaDecl> = {
+    tables: {};
+    indexes: {};
+}> = V extends readonly [
+    infer Head extends z.input<typeof delta.Version> | (z.input<typeof SchemaDecl> & {
+        delta: false;
+    }),
+    ...infer Tail extends (z.input<typeof delta.Version> | (z.input<typeof SchemaDecl> & {
+        delta: false;
+    }))[]
+] ? Head extends z.input<typeof delta.Version> ? ResolveVersions<Tail, ApplySchemaDelta<Current, Head>> : Head extends z.input<typeof SchemaDecl> ? ResolveVersions<Tail, Head> : never : Current;
+export type FullSchema<S extends z.input<typeof SchemaFile>> = ResolveVersions<S['versions']>;
+type _DBFromSchema<TBs extends Record<string, z.input<typeof Table>>> = {
+    [K in keyof TBs]: Expand<TableValue<TBs[K]>>;
+};
+/**
+ * Convert an entire schema definition file info the Kysely database schema type
+ */
+export type FromFile<S extends ReadonlyRecursive<z.input<typeof SchemaFile>>> = _DBFromSchema<FullSchema<MutableRecursive<S>>['tables']>;
+/**@deprecated use {@link FromFile} */
+export type DatabaseFromSchemaFile<S extends ReadonlyRecursive<z.input<typeof SchemaFile>>> = FromFile<S>;
+/** @internal @hidden */
+export type Raw = FromFile<typeof raw>;
+/**
+ * Get the active schema
+ */
+export declare function getFull(opt?: {
+    exclude?: string[];
+}): SchemaDecl & {
+    versions: Record<string, number>;
+};
+export declare function toSQL(schema: SchemaDecl): Generator<string>;
+export declare function toGraph(schema: SchemaDecl): Generator<string>;
+export declare const toIntrospected: {
+    boolean: string;
+    integer: string;
+    'text[]': string;
+};

package/dist/db/schema.js

@@ -0,0 +1,169 @@
+import * as io from '@axium/core/node/io';
+import { plugins } from '@axium/core/plugins';
+import { sql } from 'kysely';
+import * as z from 'zod';
+import raw from './schema.json' with { type: 'json' };
+import { database } from './connection.js';
+import { buildColumn, Index, Table } from './data.js';
+import * as delta from './delta.js';
+export * from './data.js';
+export const SchemaDecl = z.strictObject({
+    tables: z.record(z.string(), Table),
+    indexes: z.record(z.string(), Index),
+});
+export const SchemaFile = z.object({
+    format: z.literal(1),
+    versions: z.discriminatedUnion('delta', [SchemaDecl.extend({ delta: z.literal(false) }), delta.Version]).array(),
+    /** List of tables to wipe */
+    wipe: z.string().array().optional().default([]),
+    /** Set the latest version, defaults to the last one */
+    latest: z.int32().nonnegative().optional(),
+    /** Maps tables to their ACL tables, e.g. `"storage": "acl.storage"` */
+    acl_tables: z.record(z.string(), z.string()).optional().default({}),
+});
+const { data, error } = SchemaFile.safeParse(raw);
+if (error)
+    io.error('Invalid base database schema:\n' + z.prettifyError(error));
+const schema = data;
+export function* getFiles() {
+    yield ['@axium/server', schema];
+    for (const [name, plugin] of plugins) {
+        if (!plugin._db)
+            continue;
+        try {
+            yield [name, SchemaFile.parse(plugin._db)];
+        }
+        catch (e) {
+            throw `Invalid database configuration for plugin "${name}":\n${io.errorText(e)}`;
+        }
+    }
+}
+/**
+ * Get the active schema
+ */
+export function getFull(opt = {}) {
+    const fullSchema = { tables: {}, indexes: {}, versions: {} };
+    for (const [pluginName, file] of getFiles()) {
+        if (opt.exclude?.includes(pluginName))
+            continue;
+        file.latest ??= file.versions.length - 1;
+        let currentSchema = { tables: {}, indexes: {} };
+        fullSchema.versions[pluginName] = file.latest;
+        for (const [version, schema] of file.versions.entries()) {
+            if (!schema.delta)
+                currentSchema = schema;
+            else {
+                try {
+                    delta.applyToSchema(currentSchema, schema);
+                }
+                catch (e) {
+                    throw `Failed to apply version ${version - 1}->${version} delta to ${pluginName}: ${io.errorText(e)}`;
+                }
+            }
+            if (version === file.latest)
+                break;
+        }
+        for (const name of Object.keys(currentSchema.tables)) {
+            if (name in fullSchema.tables)
+                throw 'Duplicate table name in database schema: ' + name;
+            fullSchema.tables[name] = currentSchema.tables[name];
+        }
+        for (const index of Object.keys(currentSchema.indexes)) {
+            if (fullSchema.indexes[index])
+                throw 'Duplicate index in database schema: ' + index;
+            fullSchema.indexes[index] = currentSchema.indexes[index];
+        }
+    }
+    return fullSchema;
+}
+export function* toSQL(schema) {
+    for (const [tableName, table] of Object.entries(schema.tables)) {
+        let query = database.schema.createTable(tableName);
+        const columns = Object.entries(table.columns);
+        const pkColumns = columns.filter(([, column]) => column.primary).map(([name, column]) => ({ name, ...column }));
+        const needsSpecialConstraint = pkColumns.length > 1 || pkColumns.some(col => !col.required);
+        for (const [colName, column] of columns) {
+            query = query.addColumn(colName, sql.raw(column.type), buildColumn(column, !needsSpecialConstraint));
+        }
+        if (needsSpecialConstraint) {
+            query = query.addPrimaryKeyConstraint('PK_' + tableName.replaceAll('.', '_'), pkColumns.map(col => col.name));
+        }
+        yield query.compile().sql.replace('(', '(\n\t').replaceAll(', ', ',\n\t').replace(/\)$/, '\n);\n');
+    }
+    for (const [indexName, index] of Object.entries(schema.indexes)) {
+        const query = database.schema.createIndex(indexName).on(index.on).columns(index.columns).compile().sql;
+        yield query + ';\n';
+    }
+}
+export function* toGraph(schema) {
+    const esc = (s) => s.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+    const nodeId = (table) => table.replaceAll('.', '__');
+    const edges = [];
+    yield `digraph schema {
+	graph [
+		bgcolor="#111111",
+		overlap=false,
+		pad=0.5,
+		concentrate=true,
+		nodesep=1.0,
+		rankdir=LR,
+		size="16,9!",
+		ratio="fill"
+	];
+	node [color="#c6c5fe",
+		fontcolor="#c6c5fe",
+		fontname=monospace,
+		fontsize="14px",
+		height=0,
+		label="\\N",
+		shape=plain,
+		style=rounded
+	];
+	edge [color="#757575"];	
+	`;
+    for (const [tableName, table] of Object.entries(schema.tables)) {
+        const id = nodeId(tableName);
+        for (const constraint of Object.values(table.constraints)) {
+            if (constraint.type !== 'foreign_key')
+                continue;
+            for (let i = 0; i < constraint.on.length; i++) {
+                edges.push({
+                    fromTable: tableName,
+                    fromCol: constraint.on[i],
+                    toTable: constraint.target,
+                    toCol: constraint.references[i],
+                });
+            }
+        }
+        yield `\t${id} [label=<\n`;
+        yield '\t\t<TABLE BORDER="1" CELLBORDER="0" CELLSPACING="0" CELLPADDING="4">\n';
+        yield `\t\t\t<TR><TD COLSPAN="3" BGCOLOR="#44C2C4"><B>${esc(tableName)}</B></TD></TR>\n`;
+        for (const [colName, column] of Object.entries(table.columns)) {
+            const nullable = !column.required ? '?' : '';
+            const typeText = esc(column.type) + nullable;
+            let label = `${esc(colName)}: ${column.references ? `<I>${typeText}</I>` : typeText}`;
+            if (column.primary)
+                label = `<B>${label}</B>`;
+            if (column.references) {
+                const [toTable, toCol] = column.references.split('.');
+                edges.push({ fromTable: tableName, fromCol: colName, toTable, toCol });
+            }
+            yield `\t\t\t<TR><TD PORT="${esc(colName)}_l" WIDTH="2"></TD><TD ALIGN="LEFT">${label}</TD><TD PORT="${esc(colName)}_r" WIDTH="2"></TD></TR>\n`;
+        }
+        yield '\t\t</TABLE>\n\t>];\n\n';
+    }
+    for (const { fromTable, fromCol, toTable, toCol } of edges) {
+        if (fromTable != toTable) {
+            yield `\t${nodeId(fromTable)}:${fromCol}_r -> ${nodeId(toTable)}:${toCol}_l;\n`;
+            continue;
+        }
+        const id = nodeId(fromTable);
+        yield `\t${id}:${fromCol}_l:w -> ${id}:${toCol}_l:w [constraint=false];\n`;
+    }
+    yield '}\n';
+}
+export const toIntrospected = {
+    boolean: 'bool',
+    integer: 'int4',
+    'text[]': '_text',
+};

package/dist/{db.json → db/schema.json}

@@ -1,6 +1,6 @@
 {
-    "$schema": "../schemas/db.json",
-    "format": 0,
+    "$schema": "../../schemas/db.json",
+    "format": 1,
     "versions": [
         {
             "delta": false,
@@ -64,7 +64,9 @@
                     }
                 }
             },
-            "indexes": ["sessions:id", "passkeys:userId"]
+            "indexes": {
+                "passkeys_userId": { "on": "passkeys", "columns": ["userId"] }
+            }
         },
         {
             "delta": true,

package/dist/main.js

@@ -85,15 +85,15 @@ async function dbInitTables() {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         const info = db.getUpgradeInfo();
-        const schema = db.getFullSchema({ exclude: Object.keys(info.current) });
-        const delta = db.computeDelta({ tables: {}, indexes: [] }, schema);
-        if (db.deltaIsEmpty(delta))
+        const schema = db.schema.getFull({ exclude: Object.keys(info.current) });
+        const delta = db.delta.compute({ tables: {}, indexes: {} }, schema);
+        if (db.delta.isEmpty(delta))
             return;
-        for (const text of db.displayDelta(delta))
+        for (const text of db.delta.display(delta))
             console.log(text);
         await rlConfirm();
         const _ = __addDisposableResource(env_2, db.connect(), true);
-        await db.applyDelta(delta);
+        await db.delta.apply(delta);
         Object.assign(info.current, schema.versions);
         db.setUpgradeInfo(info);
     }
@@ -248,7 +248,7 @@ try {
         .addOption(opts.force)
         .action(async (opt) => {
         const tables = new Map();
-        for (const [plugin, schema] of db.getSchemaFiles()) {
+        for (const [plugin, schema] of db.schema.getFiles()) {
             for (const table of schema.wipe) {
                 const maybePlugin = tables.get(table);
                 tables.set(table, maybePlugin ? `${maybePlugin}, ${plugin}` : plugin);
@@ -309,7 +309,7 @@ try {
             io.start('Resolving database schemas');
             let schema;
             try {
-                schema = db.getFullSchema();
+                schema = db.schema.getFull();
                 io.done();
             }
             catch (e) {
@@ -350,12 +350,12 @@ try {
         .description('Generate a new password for the database user and update the config')
         .action(db.rotatePassword);
     axiumDB
-        .command('schema')
+        .command('json-schema')
         .description('Get the JSON schema for the database configuration file')
         .option('-j, --json', 'values are JSON encoded')
         .action(opt => {
         try {
-            const schema = z.toJSONSchema(db.SchemaFile, { io: 'input' });
+            const schema = z.toJSONSchema(db.schema.SchemaFile, { io: 'input' });
             console.log(opt.json ? JSON.stringify(schema, null, 4) : schema);
         }
         catch (e) {
@@ -373,7 +373,7 @@ try {
         const info = db.getUpgradeInfo();
         let empty = true;
         const from = {}, to = {};
-        for (const [name, schema] of db.getSchemaFiles()) {
+        for (const [name, schema] of db.schema.getFiles()) {
             if (!(name in info.current))
                 io.exit('Plugin is not initialized: ' + name);
             const currentVersion = info.current[name];
@@ -390,15 +390,15 @@ try {
             for (const [i, v] of versions.toReversed().entries()) {
                 if (v.delta || v == v0)
                     continue;
-                versions = [db.computeDelta(v0, v), ...versions.slice(-i)];
+                versions = [db.delta.compute(v0, v), ...versions.slice(-i)];
                 break;
             }
-            const delta = db.collapseDeltas(versions);
+            const delta = db.delta.collapse(versions);
             deltas.push(delta);
             console.log('Upgrading', name, styleText('dim', currentVersion.toString() + '->') + styleText('blueBright', target.toString()) + ':');
-            if (!db.deltaIsEmpty(delta))
+            if (!db.delta.isEmpty(delta))
                 empty = false;
-            for (const text of db.displayDelta(delta))
+            for (const text of db.delta.display(delta))
                 console.log(text);
         }
         if (empty) {
@@ -412,7 +412,7 @@ try {
         io.start('Computing delta');
         let delta;
         try {
-            delta = db.collapseDeltas(deltas);
+            delta = db.delta.collapse(deltas);
             io.done();
         }
         catch (e) {
@@ -420,14 +420,14 @@ try {
         }
         io.start('Validating delta');
         try {
-            db.validateDelta(delta);
+            db.delta.validate(delta);
             io.done();
         }
         catch (e) {
             io.exit(e);
         }
         console.log('Applying delta.');
-        await db.applyDelta(delta, opt.abort).catch(io.exit);
+        await db.delta.apply(delta, opt.abort).catch(io.exit);
         info.upgrades.push({ timestamp: new Date(), from, to });
         db.setUpgradeInfo(info);
     });
@@ -457,7 +457,7 @@ try {
         const entries = [
             { name: 'Name', current: 'Current', latest: 'Latest', available: 'Available' },
         ];
-        for (const [name, file] of db.getSchemaFiles()) {
+        for (const [name, file] of db.schema.getFiles()) {
             const available = (file.versions.length - 1).toString();
             const latest = (file.latest ?? available).toString();
             const current = currentVersions[name]?.toString();
@@ -471,6 +471,20 @@ try {
             console.log(...['name', 'current', 'latest', 'available'].map(key => styleText(i === 0 ? ['whiteBright', 'underline'] : entry[key] === undefined ? 'reset' : [], entry[key].padStart(lengths[key]))));
         }
     });
+    axiumDB
+        .command('export-schema')
+        .description('Export the DB schema')
+        .addOption(new Option('-f, --format <format>', 'Output format').choices(['sql', 'graph']).default('sql'))
+        .option('-o, --output <file>', 'Output file path')
+        .action(opt => {
+        const schema = db.schema.getFull();
+        const it = opt.format == 'sql' ? db.schema.toSQL(schema) : db.schema.toGraph(schema);
+        const out = opt.output ? createWriteStream(opt.output) : process.stdout;
+        for (const data of it)
+            out.write(data);
+        if (opt.output)
+            out.close();
+    });
     axiumConfig = program
         .command('config')
         .description('Manage the configuration')
@@ -594,16 +608,16 @@ try {
             const exclude = Object.keys(info.current);
             if (exclude.includes(plugin.name))
                 io.exit('Plugin is already initialized (database)');
-            const schema = db.getFullSchema({ exclude });
-            const delta = db.computeDelta({ tables: {}, indexes: [] }, schema);
-            if (db.deltaIsEmpty(delta)) {
+            const schema = db.schema.getFull({ exclude });
+            const delta = db.delta.compute({ tables: {}, indexes: {} }, schema);
+            if (db.delta.isEmpty(delta)) {
                 io.info('Plugin does not define any database schema.');
                 return;
             }
-            for (const text of db.displayDelta(delta))
+            for (const text of db.delta.display(delta))
                 console.log(text);
             await rlConfirm();
-            await db.applyDelta(delta);
+            await db.delta.apply(delta);
             Object.assign(info.current, schema.versions);
             db.setUpgradeInfo(info);
         }