@ronin/compiler 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -1,5 +1,12 @@
 import { z } from 'zod';
 
+declare const ExpressionSchema: z.ZodObject<{
+    __RONIN_EXPRESSION: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    __RONIN_EXPRESSION: string;
+}, {
+    __RONIN_EXPRESSION: string;
+}>;
 declare const WithInstructionSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodEffects<z.ZodObject<{
     being: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
     notBeing: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
@@ -1244,7 +1251,7 @@ declare const GetInstructionsSchema: z.ZodObject<Omit<{
     for?: string[] | Record<string, string> | undefined;
 }>;
 declare const QuerySchema: z.ZodObject<{
-    count: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<Omit<{
+    get: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<Omit<{
         with: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodEffects<z.ZodObject<{
             being: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
             notBeing: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
@@ -2096,7 +2103,7 @@ declare const QuerySchema: z.ZodObject<{
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
     }>>>>;
-    create: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<z.objectUtil.extendShape<Omit<{
+    set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<z.objectUtil.extendShape<{
         with: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodEffects<z.ZodObject<{
             being: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
             notBeing: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
@@ -2915,10 +2922,11 @@ declare const QuerySchema: z.ZodObject<{
         after: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
         limitedTo: z.ZodOptional<z.ZodNumber>;
         for: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-    }, "with" | "for">, {
+    }, {
         to: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>>, Record<string, any>, Record<string, any>>;
     }>, "strip", z.ZodTypeAny, {
         to: Record<string, any>;
+        with?: Record<string, any> | Record<string, any>[] | undefined;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -2932,8 +2940,10 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
+        for?: string[] | Record<string, string> | undefined;
     }, {
         to: Record<string, any>;
+        with?: Record<string, any> | Record<string, any>[] | undefined;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -2947,8 +2957,9 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
+        for?: string[] | Record<string, string> | undefined;
     }>>>;
-    drop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
+    add: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<z.objectUtil.extendShape<Omit<{
         with: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodEffects<z.ZodObject<{
             being: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
             notBeing: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
@@ -3767,8 +3778,10 @@ declare const QuerySchema: z.ZodObject<{
         after: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
         limitedTo: z.ZodOptional<z.ZodNumber>;
         for: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-    }, "to">, "strip", z.ZodTypeAny, {
-        with?: Record<string, any> | Record<string, any>[] | undefined;
+    }, "with" | "for">, {
+        to: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>>, Record<string, any>, Record<string, any>>;
+    }>, "strip", z.ZodTypeAny, {
+        to: Record<string, any>;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -3782,9 +3795,8 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
-        for?: string[] | Record<string, string> | undefined;
     }, {
-        with?: Record<string, any> | Record<string, any>[] | undefined;
+        to: Record<string, any>;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -3798,9 +3810,8 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
-        for?: string[] | Record<string, string> | undefined;
     }>>>;
-    get: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<Omit<{
+    delete: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<Omit<{
         with: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodEffects<z.ZodObject<{
             being: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
             notBeing: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
@@ -4651,8 +4662,8 @@ declare const QuerySchema: z.ZodObject<{
         after?: string | null | undefined;
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
-    }>>>>;
-    set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<z.objectUtil.extendShape<{
+    }>>>;
+    count: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<Omit<{
         with: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodEffects<z.ZodObject<{
             being: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
             notBeing: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>, "many">]>>;
@@ -5471,10 +5482,7 @@ declare const QuerySchema: z.ZodObject<{
         after: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
         limitedTo: z.ZodOptional<z.ZodNumber>;
         for: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodString>]>>;
-    }, {
-        to: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodAny]>>, Record<string, any>, Record<string, any>>;
-    }>, "strip", z.ZodTypeAny, {
-        to: Record<string, any>;
+    }, "to">, "strip", z.ZodTypeAny, {
         with?: Record<string, any> | Record<string, any>[] | undefined;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
@@ -5491,7 +5499,6 @@ declare const QuerySchema: z.ZodObject<{
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
     }, {
-        to: Record<string, any>;
         with?: Record<string, any> | Record<string, any>[] | undefined;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
@@ -5507,7 +5514,81 @@ declare const QuerySchema: z.ZodObject<{
         after?: string | null | undefined;
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
-    }>>>;
+    }>>>>;
+    create: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        model: z.ZodString;
+        to: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        to: Record<string, any>;
+        model: string;
+    }, {
+        to: Record<string, any>;
+        model: string;
+    }>, z.ZodObject<{
+        model: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        model: Record<string, any>;
+    }, {
+        model: Record<string, any>;
+    }>]>>;
+    alter: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+    }, {
+        model: string;
+    }>, z.ZodUnion<[z.ZodObject<{
+        to: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        to: Record<string, any>;
+    }, {
+        to: Record<string, any>;
+    }>, z.ZodObject<{
+        create: z.ZodUnion<[z.ZodIntersection<z.ZodRecord<z.ZodEnum<["field", "index", "trigger", "preset"]>, z.ZodString>, z.ZodObject<{
+            to: z.ZodRecord<z.ZodString, z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            to: Record<string, any>;
+        }, {
+            to: Record<string, any>;
+        }>>, z.ZodRecord<z.ZodEnum<["field", "index", "trigger", "preset"]>, z.ZodRecord<z.ZodString, z.ZodAny>>]>;
+    }, "strip", z.ZodTypeAny, {
+        create: (Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        }) | Partial<Record<"field" | "index" | "trigger" | "preset", Record<string, any>>>;
+    }, {
+        create: (Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        }) | Partial<Record<"field" | "index" | "trigger" | "preset", Record<string, any>>>;
+    }>, z.ZodObject<{
+        alter: z.ZodIntersection<z.ZodRecord<z.ZodEnum<["field", "index", "trigger", "preset"]>, z.ZodString>, z.ZodObject<{
+            to: z.ZodRecord<z.ZodString, z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            to: Record<string, any>;
+        }, {
+            to: Record<string, any>;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        alter: Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        };
+    }, {
+        alter: Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        };
+    }>, z.ZodObject<{
+        drop: z.ZodRecord<z.ZodEnum<["field", "index", "trigger", "preset"]>, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        drop: Partial<Record<"field" | "index" | "trigger" | "preset", string>>;
+    }, {
+        drop: Partial<Record<"field" | "index" | "trigger" | "preset", string>>;
+    }>]>>>;
+    drop: z.ZodOptional<z.ZodObject<{
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+    }, {
+        model: string;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     get?: Record<string, {
         with?: Record<string, any> | Record<string, any>[] | undefined;
@@ -5544,8 +5625,8 @@ declare const QuerySchema: z.ZodObject<{
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
     }> | undefined;
-    drop?: Record<string, {
-        with?: Record<string, any> | Record<string, any>[] | undefined;
+    add?: Record<string, {
+        to: Record<string, any>;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -5559,10 +5640,9 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
-        for?: string[] | Record<string, string> | undefined;
     }> | undefined;
-    create?: Record<string, {
-        to: Record<string, any>;
+    delete?: Record<string, {
+        with?: Record<string, any> | Record<string, any>[] | undefined;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -5576,6 +5656,7 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
+        for?: string[] | Record<string, string> | undefined;
     }> | undefined;
     count?: Record<string, {
         with?: Record<string, any> | Record<string, any>[] | undefined;
@@ -5594,6 +5675,30 @@ declare const QuerySchema: z.ZodObject<{
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
     } | null> | undefined;
+    create?: {
+        to: Record<string, any>;
+        model: string;
+    } | {
+        model: Record<string, any>;
+    } | undefined;
+    alter?: ({
+        model: string;
+    } & ({
+        to: Record<string, any>;
+    } | {
+        create: (Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        }) | Partial<Record<"field" | "index" | "trigger" | "preset", Record<string, any>>>;
+    } | {
+        alter: Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        };
+    } | {
+        drop: Partial<Record<"field" | "index" | "trigger" | "preset", string>>;
+    })) | undefined;
+    drop?: {
+        model: string;
+    } | undefined;
 }, {
     get?: Record<string, {
         with?: Record<string, any> | Record<string, any>[] | undefined;
@@ -5630,8 +5735,8 @@ declare const QuerySchema: z.ZodObject<{
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
     }> | undefined;
-    drop?: Record<string, {
-        with?: Record<string, any> | Record<string, any>[] | undefined;
+    add?: Record<string, {
+        to: Record<string, any>;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -5645,10 +5750,9 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
-        for?: string[] | Record<string, string> | undefined;
     }> | undefined;
-    create?: Record<string, {
-        to: Record<string, any>;
+    delete?: Record<string, {
+        with?: Record<string, any> | Record<string, any>[] | undefined;
         including?: Record<string, any> | undefined;
         selecting?: string[] | undefined;
         orderedBy?: {
@@ -5662,6 +5766,7 @@ declare const QuerySchema: z.ZodObject<{
         before?: string | null | undefined;
         after?: string | null | undefined;
         limitedTo?: number | undefined;
+        for?: string[] | Record<string, string> | undefined;
     }> | undefined;
     count?: Record<string, {
         with?: Record<string, any> | Record<string, any>[] | undefined;
@@ -5680,10 +5785,35 @@ declare const QuerySchema: z.ZodObject<{
         limitedTo?: number | undefined;
         for?: string[] | Record<string, string> | undefined;
     } | null> | undefined;
+    create?: {
+        to: Record<string, any>;
+        model: string;
+    } | {
+        model: Record<string, any>;
+    } | undefined;
+    alter?: ({
+        model: string;
+    } & ({
+        to: Record<string, any>;
+    } | {
+        create: (Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        }) | Partial<Record<"field" | "index" | "trigger" | "preset", Record<string, any>>>;
+    } | {
+        alter: Partial<Record<"field" | "index" | "trigger" | "preset", string>> & {
+            to: Record<string, any>;
+        };
+    } | {
+        drop: Partial<Record<"field" | "index" | "trigger" | "preset", string>>;
+    })) | undefined;
+    drop?: {
+        model: string;
+    } | undefined;
 }>;
 
 type GetInstructions = z.infer<typeof GetInstructionsSchema>;
 type WithInstruction = z.infer<typeof WithInstructionSchema>;
+type Expression = z.infer<typeof ExpressionSchema>;
 type Query = z.infer<typeof QuerySchema>;
 interface Statement {
     statement: string;
@@ -5691,21 +5821,58 @@ interface Statement {
     returning?: boolean;
 }
 
+type ModelFieldCollation = 'BINARY' | 'NOCASE' | 'RTRIM';
 type ModelFieldBasics = {
+    /** The label that should be used when displaying the field on the RONIN dashboard. */
     name?: string;
+    /** Allows for addressing the field programmatically. */
     slug: string;
+    /** How the field should be displayed visually on the RONIN dashboard. */
     displayAs?: string;
+    /**
+     * If set, only one record of the same model will be allowed to exist with a given
+     * value for the field.
+     */
     unique?: boolean;
+    /**
+     * Whether a value must be provided for the field. If this attribute is set and no
+     * value is provided, an error will be thrown.
+     */
     required?: boolean;
+    /**
+     * The value that should be inserted into the field in the case that no value was
+     * explicitly provided for it when a record is created.
+     */
     defaultValue?: unknown;
+    /**
+     * An expression that should be evaluated to form the value of the field. The
+     * expression can either be VIRTUAL (evaluated whenever a record is read) or STORED
+     * (evaluated whenever a record is created or updated).
+     */
+    computedAs?: {
+        kind: 'VIRTUAL' | 'STORED';
+        value: Expression;
+    };
+    /** An expression that gets evaluated every time a value is provided for the field. */
+    check?: Expression;
+    /**
+     * If the field is of type `string`, setting this attribute defines the collation
+     * sequence to use for the field value.
+     */
+    collation?: ModelFieldCollation;
+    /**
+     * If the field is of type `number`, setting this attribute will automatically increment
+     * the value of the field with every new record that gets inserted.
+     */
+    increment?: boolean;
 };
 type ModelFieldNormal = ModelFieldBasics & {
     type: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'group';
 };
 type ModelFieldReferenceAction = 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT' | 'NO ACTION';
 type ModelFieldReference = ModelFieldBasics & {
-    type: 'reference';
-    target: Omit<Partial<Model>, 'slug'> & Pick<Model, 'slug'>;
+    type: 'link';
+    target: string;
     kind?: 'one' | 'many';
     actions?: {
         onDelete?: ModelFieldReferenceAction;
@@ -5715,7 +5882,7 @@ type ModelFieldReference = ModelFieldBasics & {
 type ModelField = ModelFieldNormal | ModelFieldReference;
 type ModelIndexField = {
     /** The collating sequence used for text placed inside the field. */
-    collation?: 'BINARY' | 'NOCASE' | 'RTRIM';
+    collation?: ModelFieldCollation;
     /** How the records in the index should be ordered. */
     order?: 'ASC' | 'DESC';
 } & ({
@@ -5730,6 +5897,10 @@ type ModelIndex = {
      * The list of fields in the model for which the index should be created.
      */
     fields: Array<ModelIndexField>;
+    /**
+     * The identifier of the index.
+     */
+    slug?: string;
     /**
      * Whether only one record with a unique value for the provided fields will be allowed.
      */
@@ -5750,7 +5921,7 @@ type ModelTriggerField = {
 type ModelTrigger = {
     /** The type of query for which the trigger should fire. */
     action: 'INSERT' | 'UPDATE' | 'DELETE';
-    /** When the trigger should fire in the case that a maching query is executed. */
+    /** When the trigger should fire in the case that a matching query is executed. */
     when: 'BEFORE' | 'DURING' | 'AFTER';
     /** A list of queries that should be executed when the trigger fires. */
     effects: Array<Query>;
@@ -5787,11 +5958,11 @@ interface Model {
     tableAlias?: string;
     /**
      * If the model is used to associate two models with each other (in the case of
-     * many-cardinality reference fields), this property should contain the field to which
-     * the associative model should be mounted.
+     * many-cardinality link fields), this property should contain the field slug to which
+     * the associative model should be mounted on the source model.
      */
     associationSlug?: string;
-    fields?: Array<ModelField>;
+    fields: Array<ModelField>;
     indexes?: Array<ModelIndex>;
     triggers?: Array<ModelTrigger>;
     presets?: Array<ModelPreset>;

package/dist/index.js

@@ -187,14 +187,14 @@ var composeConditions = (models, model, statementParams, instructionName, value,
         { ...options, fieldSlug: options.fieldSlug }
       );
     }
-    if (modelField.type === "reference" && isNested) {
+    if (modelField.type === "link" && isNested) {
       const keys = Object.keys(value);
       const values = Object.values(value);
       let recordTarget;
       if (keys.length === 1 && keys[0] === "id") {
         recordTarget = values[0];
       } else {
-        const relatedModel = getModelBySlug(models, modelField.target.slug);
+        const relatedModel = getModelBySlug(models, modelField.target);
         const subQuery = {
           get: {
             [relatedModel.slug]: {
@@ -490,16 +490,16 @@ var SYSTEM_MODELS = [
       { slug: "type", type: "string", required: true },
       {
         slug: "model",
-        type: "reference",
-        target: { slug: "model" },
+        type: "link",
+        target: "model",
         required: true
       },
       { slug: "required", type: "boolean" },
       { slug: "defaultValue", type: "string" },
       { slug: "unique", type: "boolean" },
       { slug: "autoIncrement", type: "boolean" },
-      // Only allowed for fields of type "reference".
-      { slug: "target", type: "reference", target: { slug: "model" } },
+      // Only allowed for fields of type "link".
+      { slug: "target", type: "string" },
       { slug: "kind", type: "string" },
       { slug: "actions", type: "group" },
       { slug: "actions.onDelete", type: "string" },
@@ -516,8 +516,8 @@ var SYSTEM_MODELS = [
       { slug: "slug", type: "string", required: true },
       {
         slug: "model",
-        type: "reference",
-        target: { slug: "model" },
+        type: "link",
+        target: "model",
         required: true
       },
       { slug: "unique", type: "boolean" },
@@ -535,8 +535,8 @@ var SYSTEM_MODELS = [
       { slug: "slug", type: "string", required: true },
       {
         slug: "model",
-        type: "reference",
-        target: { slug: "model" },
+        type: "link",
+        target: "model",
         required: true
       },
       { slug: "when", type: "string", required: true },
@@ -552,8 +552,8 @@ var SYSTEM_MODELS = [
       { slug: "slug", type: "string", required: true },
       {
         slug: "model",
-        type: "reference",
-        target: { slug: "model" },
+        type: "link",
+        target: "model",
         required: true
       },
       { slug: "instructions", type: "json", required: true }
@@ -568,8 +568,8 @@ var addSystemModels = (models) => {
   const associativeModels = models.flatMap((model) => {
     const addedModels = [];
     for (const field of model.fields || []) {
-      if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-        const relatedModel = getModelBySlug(models, field.target.slug);
+      if (field.type === "link" && !field.slug.startsWith("ronin.")) {
+        const relatedModel = getModelBySlug(models, field.target);
         let fieldSlug = relatedModel.slug;
         if (field.kind === "many") {
           fieldSlug = composeAssociationModelSlug(model, field);
@@ -580,13 +580,13 @@ var addSystemModels = (models) => {
             fields: [
               {
                 slug: "source",
-                type: "reference",
-                target: { slug: model.slug }
+                type: "link",
+                target: model.slug
               },
               {
                 slug: "target",
-                type: "reference",
-                target: { slug: relatedModel.slug }
+                type: "link",
+                target: relatedModel.slug
               }
             ]
           });
@@ -600,8 +600,8 @@ var addSystemModels = (models) => {
 var addDefaultModelPresets = (list, model) => {
   const defaultPresets = [];
   for (const field of model.fields || []) {
-    if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-      const relatedModel = getModelBySlug(list, field.target.slug);
+    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
+      const relatedModel = getModelBySlug(list, field.target);
       if (field.kind === "many") continue;
       defaultPresets.push({
         instructions: {
@@ -611,7 +611,7 @@ var addDefaultModelPresets = (list, model) => {
                 get: {
                   [relatedModel.slug]: {
                     with: {
-                      // Compare the `id` field of the related model to the reference field on
+                      // Compare the `id` field of the related model to the link field on
                       // the root model (`field.slug`).
                       id: {
                         [RONIN_MODEL_SYMBOLS.EXPRESSION]: `${RONIN_MODEL_SYMBOLS.FIELD_PARENT}${field.slug}`
@@ -629,7 +629,7 @@ var addDefaultModelPresets = (list, model) => {
   }
   const childModels = list.map((subModel) => {
     const field = subModel.fields?.find((field2) => {
-      return field2.type === "reference" && field2.target.slug === model.slug;
+      return field2.type === "link" && field2.target === model.slug;
     });
     if (!field) return null;
     return { model: subModel, field };
@@ -665,12 +665,12 @@ var addDefaultModelPresets = (list, model) => {
   return model;
 };
 var mappedInstructions = {
-  create: "to",
+  add: "to",
   set: "with",
-  drop: "with"
+  delete: "with"
 };
 var typesInSQLite = {
-  reference: "TEXT",
+  link: "TEXT",
   string: "TEXT",
   date: "DATETIME",
   blob: "TEXT",
@@ -678,7 +678,7 @@ var typesInSQLite = {
   number: "INTEGER",
   json: "TEXT"
 };
-var getFieldStatement = (field) => {
+var getFieldStatement = (models, model, field) => {
   if (field.type === "group") return null;
   let statement = `"${field.slug}" ${typesInSQLite[field.type]}`;
   if (field.slug === "id") statement += " PRIMARY KEY";
@@ -686,9 +686,20 @@ var getFieldStatement = (field) => {
   if (field.required === true) statement += " NOT NULL";
   if (typeof field.defaultValue !== "undefined")
     statement += ` DEFAULT ${field.defaultValue}`;
-  if (field.type === "reference") {
+  if (field.collation) statement += ` COLLATE ${field.collation}`;
+  if (field.increment === true) statement += " AUTOINCREMENT";
+  if (typeof field.check !== "undefined") {
+    const symbol = getSymbol(field.check);
+    statement += ` CHECK (${parseFieldExpression(model, "to", symbol?.value)})`;
+  }
+  if (typeof field.computedAs !== "undefined") {
+    const { kind, value } = field.computedAs;
+    const symbol = getSymbol(value);
+    statement += ` GENERATED ALWAYS AS (${parseFieldExpression(model, "to", symbol?.value)}) ${kind}`;
+  }
+  if (field.type === "link") {
     const actions = field.actions || {};
-    const targetTable = convertToSnakeCase(pluralize(field.target.slug));
+    const targetTable = getModelBySlug(models, field.target).table;
     statement += ` REFERENCES ${targetTable}("id")`;
     for (const trigger in actions) {
       const triggerName = trigger.toUpperCase().slice(2);
@@ -698,18 +709,17 @@ var getFieldStatement = (field) => {
   }
   return statement;
 };
-var addModelQueries = (models, queryDetails, dependencyStatements) => {
-  const { queryType, queryModel, queryInstructions: queryInstructionsRaw } = queryDetails;
-  const queryInstructions = queryInstructionsRaw;
-  if (!["create", "set", "drop"].includes(queryType)) return queryInstructions;
-  if (!SYSTEM_MODEL_SLUGS.includes(queryModel)) return queryInstructions;
+var addModelQueries = (models, dependencyStatements, queryDetails) => {
+  const { queryType, queryModel, queryInstructions } = queryDetails;
+  if (!["add", "set", "delete"].includes(queryType)) return;
+  if (!SYSTEM_MODEL_SLUGS.includes(queryModel)) return;
   const instructionName = mappedInstructions[queryType];
   const instructionList = queryInstructions[instructionName];
   const kind = getModelBySlug(SYSTEM_MODELS, queryModel).pluralSlug;
   let tableAction = "ALTER";
   let queryTypeReadable = null;
   switch (queryType) {
-    case "create": {
+    case "add": {
       if (kind === "models" || kind === "indexes" || kind === "triggers") {
         tableAction = "CREATE";
       }
@@ -721,7 +731,7 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
       queryTypeReadable = "updating";
       break;
     }
-    case "drop": {
+    case "delete": {
       if (kind === "models" || kind === "indexes" || kind === "triggers") {
         tableAction = "DROP";
       }
@@ -730,25 +740,11 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
     }
   }
   const slug = instructionList?.slug?.being || instructionList?.slug;
-  if (!slug) {
-    throw new RoninError({
-      message: `When ${queryTypeReadable} ${kind}, a \`slug\` field must be provided in the \`${instructionName}\` instruction.`,
-      code: "MISSING_FIELD",
-      fields: ["slug"]
-    });
-  }
   const modelInstruction = instructionList?.model;
   const modelSlug = modelInstruction?.slug?.being || modelInstruction?.slug;
-  if (kind !== "models" && !modelSlug) {
-    throw new RoninError({
-      message: `When ${queryTypeReadable} ${kind}, a \`model.slug\` field must be provided in the \`${instructionName}\` instruction.`,
-      code: "MISSING_FIELD",
-      fields: ["model.slug"]
-    });
-  }
   const usableSlug = kind === "models" ? slug : modelSlug;
   const tableName = convertToSnakeCase(pluralize(usableSlug));
-  const targetModel = kind === "models" && queryType === "create" ? null : getModelBySlug(models, usableSlug);
+  const targetModel = kind === "models" && queryType === "add" ? null : getModelBySlug(models, usableSlug);
   if (kind === "indexes") {
     const indexName = convertToSnakeCase(slug);
     const unique = instructionList?.unique;
@@ -756,7 +752,7 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
     const fields = instructionList?.fields;
     const params = [];
     let statement2 = `${tableAction}${unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
-    if (queryType === "create") {
+    if (queryType === "add") {
       const model = targetModel;
       const columns = fields.map((field) => {
         let fieldSelector = "";
@@ -781,13 +777,13 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
       }
     }
     dependencyStatements.push({ statement: statement2, params });
-    return queryInstructions;
+    return;
   }
   if (kind === "triggers") {
     const triggerName = convertToSnakeCase(slug);
     const params = [];
     let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
-    if (queryType === "create") {
+    if (queryType === "add") {
       const currentModel = targetModel;
       const { when, action } = instructionList;
       const statementParts = [`${when} ${action}`];
@@ -833,26 +829,19 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
       statement2 += ` ${statementParts.join(" ")}`;
     }
     dependencyStatements.push({ statement: statement2, params });
-    return queryInstructions;
+    return;
   }
   const statement = `${tableAction} TABLE "${tableName}"`;
   if (kind === "models") {
-    if (queryType === "create" || queryType === "set") {
-      const modelWithFields = addDefaultModelFields(
-        queryInstructions.to,
-        queryType === "create"
-      );
-      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
-      queryInstructions.to = modelWithPresets;
-    }
-    if (queryType === "create") {
-      const { fields } = queryInstructions.to;
-      const columns = fields.map(getFieldStatement).filter(Boolean);
+    if (queryType === "add") {
+      const newModel = queryInstructions.to;
+      const { fields } = newModel;
+      const columns = fields.map((field) => getFieldStatement(models, newModel, field)).filter(Boolean);
       dependencyStatements.push({
         statement: `${statement} (${columns.join(", ")})`,
         params: []
       });
-      models.push(queryInstructions.to);
+      models.push(newModel);
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.pluralSlug;
       if (newSlug) {
@@ -863,23 +852,17 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
         });
       }
       Object.assign(targetModel, queryInstructions.to);
-    } else if (queryType === "drop") {
+    } else if (queryType === "delete") {
       models.splice(models.indexOf(targetModel), 1);
       dependencyStatements.push({ statement, params: [] });
     }
-    return queryInstructions;
+    return;
   }
   if (kind === "fields") {
-    if (queryType === "create") {
-      if (!instructionList.type) {
-        throw new RoninError({
-          message: `When ${queryTypeReadable} fields, a \`type\` field must be provided in the \`to\` instruction.`,
-          code: "MISSING_FIELD",
-          fields: ["type"]
-        });
-      }
+    if (queryType === "add") {
+      if (!instructionList.type) instructionList.type = "string";
       dependencyStatements.push({
-        statement: `${statement} ADD COLUMN ${getFieldStatement(instructionList)}`,
+        statement: `${statement} ADD COLUMN ${getFieldStatement(models, targetModel, instructionList)}`,
         params: []
       });
     } else if (queryType === "set") {
@@ -890,14 +873,13 @@ var addModelQueries = (models, queryDetails, dependencyStatements) => {
           params: []
         });
       }
-    } else if (queryType === "drop") {
+    } else if (queryType === "delete") {
       dependencyStatements.push({
         statement: `${statement} DROP COLUMN "${slug}"`,
         params: []
       });
     }
   }
-  return queryInstructions;
 };
 
 // src/instructions/before-after.ts
@@ -1158,12 +1140,12 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
   const currentTime = (/* @__PURE__ */ new Date()).toISOString();
   const { with: withInstruction, to: toInstruction } = instructions;
   const defaultFields = {};
-  if (queryType === "create") {
+  if (queryType === "add") {
     defaultFields.id = toInstruction.id || generateRecordId(model.idPrefix);
   }
   defaultFields.ronin = {
     // If records are being created, set their creation time.
-    ...queryType === "create" ? { createdAt: currentTime } : {},
+    ...queryType === "add" ? { createdAt: currentTime } : {},
     // If records are being created or updated, set their update time.
     updatedAt: currentTime,
     // Allow for overwriting the default values provided above.
@@ -1201,17 +1183,17 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
   for (const fieldSlug in toInstruction) {
     const fieldValue = toInstruction[fieldSlug];
     const fieldDetails = getFieldFromModel(model, fieldSlug, "to");
-    if (fieldDetails.field.type === "reference" && fieldDetails.field.kind === "many") {
+    if (fieldDetails.field.type === "link" && fieldDetails.field.kind === "many") {
       delete toInstruction[fieldSlug];
       const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
       const composeStatement = (subQueryType, value) => {
-        const source = queryType === "create" ? { id: toInstruction.id } : withInstruction;
+        const source = queryType === "add" ? { id: toInstruction.id } : withInstruction;
         const recordDetails = { source };
         if (value) recordDetails.target = value;
         return compileQueryInput(
           {
             [subQueryType]: {
-              [associativeModelSlug]: subQueryType === "create" ? { to: recordDetails } : { with: recordDetails }
+              [associativeModelSlug]: subQueryType === "add" ? { to: recordDetails } : { with: recordDetails }
             }
           },
           models,
@@ -1220,25 +1202,25 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
         ).main;
       };
       if (Array.isArray(fieldValue)) {
-        dependencyStatements.push(composeStatement("drop"));
+        dependencyStatements.push(composeStatement("delete"));
         for (const record of fieldValue) {
-          dependencyStatements.push(composeStatement("create", record));
+          dependencyStatements.push(composeStatement("add", record));
         }
       } else if (isObject(fieldValue)) {
         for (const recordToAdd of fieldValue.containing || []) {
-          dependencyStatements.push(composeStatement("create", recordToAdd));
+          dependencyStatements.push(composeStatement("add", recordToAdd));
         }
         for (const recordToRemove of fieldValue.notContaining || []) {
-          dependencyStatements.push(composeStatement("drop", recordToRemove));
+          dependencyStatements.push(composeStatement("delete", recordToRemove));
         }
       }
     }
   }
   let statement = composeConditions(models, model, statementParams, "to", toInstruction, {
     parentModel,
-    type: queryType === "create" ? "fields" : void 0
+    type: queryType === "add" ? "fields" : void 0
   });
-  if (queryType === "create") {
+  if (queryType === "add") {
     const deepStatement = composeConditions(
       models,
       model,
@@ -1266,11 +1248,6 @@ var compileQueryInput = (query, models, statementParams, options) => {
   let instructions = formatIdentifiers(model, queryInstructions);
   const dependencyStatements = [];
   const returning = options?.returning ?? true;
-  instructions = addModelQueries(
-    models,
-    { queryType, queryModel, queryInstructions: instructions },
-    dependencyStatements
-  );
   if (instructions && Object.hasOwn(instructions, "for")) {
     instructions = handleFor(model, instructions);
   }
@@ -1283,17 +1260,17 @@ var compileQueryInput = (query, models, statementParams, options) => {
     case "get":
       statement += `SELECT ${columns} FROM `;
       break;
-    case "count":
-      statement += `SELECT COUNT(${columns}) FROM `;
-      break;
-    case "drop":
-      statement += "DELETE FROM ";
+    case "set":
+      statement += "UPDATE ";
       break;
-    case "create":
+    case "add":
       statement += "INSERT INTO ";
       break;
-    case "set":
-      statement += "UPDATE ";
+    case "delete":
+      statement += "DELETE FROM ";
+      break;
+    case "count":
+      statement += `SELECT COUNT(${columns}) FROM `;
       break;
   }
   let isJoiningMultipleRows = false;
@@ -1314,7 +1291,7 @@ var compileQueryInput = (query, models, statementParams, options) => {
   } else {
     statement += `"${model.table}" `;
   }
-  if (queryType === "create" || queryType === "set") {
+  if (queryType === "add" || queryType === "set") {
     if (!isObject(instructions.to) || Object.keys(instructions.to).length === 0) {
       throw new RoninError({
         message: `When using a \`${queryType}\` query, the \`to\` instruction must be a non-empty object.`,
@@ -1334,7 +1311,7 @@ var compileQueryInput = (query, models, statementParams, options) => {
     statement += `${toStatement} `;
   }
   const conditions = [];
-  if (queryType !== "create" && instructions && Object.hasOwn(instructions, "with")) {
+  if (queryType !== "add" && instructions && Object.hasOwn(instructions, "with")) {
     const withStatement = handleWith(
       models,
       model,
@@ -1387,7 +1364,7 @@ var compileQueryInput = (query, models, statementParams, options) => {
   if (queryType === "get" && !isJoiningMultipleRows && (single || instructions?.limitedTo)) {
     statement += handleLimitedTo(single, instructions?.limitedTo);
   }
-  if (["create", "set", "drop"].includes(queryType) && returning) {
+  if (["add", "set", "delete"].includes(queryType) && returning) {
     statement += "RETURNING * ";
   }
   const mainStatement = {
@@ -1401,6 +1378,122 @@ var compileQueryInput = (query, models, statementParams, options) => {
   };
 };
 
+// src/utils/meta.ts
+var transformMetaQuery = (models, dependencyStatements, query) => {
+  if (query.create) {
+    const init = query.create.model;
+    const details = "to" in query.create ? { slug: init, ...query.create.to } : init;
+    const modelWithFields = addDefaultModelFields(details, true);
+    const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+    const instructions = {
+      to: modelWithPresets
+    };
+    addModelQueries(models, dependencyStatements, {
+      queryType: "add",
+      queryModel: "model",
+      queryInstructions: instructions
+    });
+    return {
+      add: {
+        model: instructions
+      }
+    };
+  }
+  if (query.drop) {
+    const slug = query.drop.model;
+    const instructions = {
+      with: { slug }
+    };
+    addModelQueries(models, dependencyStatements, {
+      queryType: "delete",
+      queryModel: "model",
+      queryInstructions: instructions
+    });
+    return {
+      delete: {
+        model: instructions
+      }
+    };
+  }
+  if (query.alter) {
+    const slug = query.alter.model;
+    if ("to" in query.alter) {
+      const modelWithFields = addDefaultModelFields(query.alter.to, false);
+      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+      const instructions2 = {
+        with: { slug },
+        to: modelWithPresets
+      };
+      addModelQueries(models, dependencyStatements, {
+        queryType: "set",
+        queryModel: "model",
+        queryInstructions: instructions2
+      });
+      return {
+        set: {
+          model: instructions2
+        }
+      };
+    }
+    if ("create" in query.alter) {
+      const type2 = Object.keys(query.alter.create)[0];
+      const item = query.alter.create[type2];
+      const completeItem = { slug: item.slug || `${type2}_slug`, ...item };
+      const instructions2 = {
+        to: {
+          model: { slug },
+          ...completeItem
+        }
+      };
+      addModelQueries(models, dependencyStatements, {
+        queryType: "add",
+        queryModel: type2,
+        queryInstructions: instructions2
+      });
+      return {
+        add: {
+          [type2]: instructions2
+        }
+      };
+    }
+    if ("alter" in query.alter) {
+      const type2 = Object.keys(query.alter.alter)[0];
+      const itemSlug2 = query.alter.alter[type2];
+      const newItem = query.alter.alter.to;
+      const instructions2 = {
+        with: { model: { slug }, slug: itemSlug2 },
+        to: newItem
+      };
+      addModelQueries(models, dependencyStatements, {
+        queryType: "set",
+        queryModel: type2,
+        queryInstructions: instructions2
+      });
+      return {
+        set: {
+          [type2]: instructions2
+        }
+      };
+    }
+    const type = Object.keys(query.alter.drop)[0];
+    const itemSlug = query.alter.drop[type];
+    const instructions = {
+      with: { model: { slug }, slug: itemSlug }
+    };
+    addModelQueries(models, dependencyStatements, {
+      queryType: "delete",
+      queryModel: type,
+      queryInstructions: instructions
+    });
+    return {
+      delete: {
+        [type]: instructions
+      }
+    };
+  }
+  return query;
+};
+
 // src/index.ts
 var compileQueries = (queries, models, options) => {
   const modelList = addSystemModels(models).map((model) => {
@@ -1412,8 +1505,13 @@ var compileQueries = (queries, models, options) => {
   const dependencyStatements = [];
   const mainStatements = [];
   for (const query of queries) {
+    const transformedQuery = transformMetaQuery(
+      modelListWithPresets,
+      dependencyStatements,
+      query
+    );
     const result = compileQueryInput(
-      query,
+      transformedQuery,
       modelListWithPresets,
       options?.inlineParams ? null : []
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {