@xdbml/parse 0.5.0 → 0.6.0

package/dist/ast.d.ts

@@ -68,7 +68,7 @@ export interface EntityDeclaration {
     span: Span;
 }
 export type EntityKeyword = 'Table' | 'Entity' | 'Collection' | 'Record';
-export type EntityBodyItem = FieldDeclaration | IndexesBlock | ChecksBlock | NoteBlock | PartialInjection | RecordsBlock;
+export type EntityBodyItem = FieldDeclaration | IndexesBlock | ChecksBlock | ConstraintsBlock | NoteBlock | PartialInjection | RecordsBlock;
 export interface FieldDeclaration {
     kind: 'FieldDeclaration';
     name: string;
@@ -81,7 +81,11 @@ export interface FieldDeclaration {
 export type TypeExpression = ScalarType | ObjectType | ArrayType | TupleType | MapType | SetType | UnionType | OneOfType | AnyOfType | AllOfType | JsonType | NamedTypeReference;
 export interface ScalarType {
     kind: 'ScalarType';
-    /** The base name: `int`, `varchar`, `decimal`, `objectId`, `Decimal128`, etc. */
+    /**
+     * The base name: `int`, `varchar`, `decimal`, `objectId`, `Decimal128`,
+     * etc. May be qualified, `core.job_status`, when it names an Enum
+     * declared in a container (spec §16).
+     */
     name: string;
     /** `(p, s)` parameters, e.g. for `decimal(19, 4)`. Numbers preserved as strings to keep round-trip fidelity. */
     params?: string[];
@@ -229,6 +233,11 @@ export interface EnumDeclaration {
     kind: 'EnumDeclaration';
     /** Source casing of `enum` or `Enum`; both are valid. */
     keywordCasing: string;
+    /**
+     * May be `container.enum` form when declared schema-qualified at the
+     * top level (`enum core.job_status`); the resolver files it under that
+     * container, like an Enum declared inside the Container block.
+     */
     name: string;
     values: EnumValue[];
     span: Span;
@@ -319,12 +328,34 @@ export interface ChecksBlock {
 }
 export interface CheckEntry {
     kind: 'CheckEntry';
-    /** Source text inside the backticks, no surrounding backticks. */
+    /** Source text inside the delimiters, without them. */
     expression: string;
+    /**
+     * How the source wrote the expression (spec §10.5, v0.6): in backticks,
+     * or in single or triple quotes. Both mean the same check; the raw AST
+     * keeps the form. Absent on entries built by older code paths, which
+     * only ever read backticks.
+     */
+    delimiter?: 'backtick' | 'quote';
     /** Optional settings -- typically `name:` and/or `note:`. */
     settings: Setting[];
     span: Span;
 }
+export interface ConstraintsBlock {
+    kind: 'ConstraintsBlock';
+    entries: ConstraintEntry[];
+    span: Span;
+}
+export type ConstraintEntry = KeyConstraintEntry | CheckEntry;
+export interface KeyConstraintEntry {
+    kind: 'KeyConstraintEntry';
+    /** One path per key field, in key order. */
+    fields: PathSegment[][];
+    /** True when the source wrote the fields in parentheses. */
+    parenthesized: boolean;
+    settings: Setting[];
+    span: Span;
+}
 export interface TablePartialDeclaration {
     kind: 'TablePartialDeclaration';
     name: string;
@@ -491,6 +522,12 @@ export interface Setting {
     nameSource: string;
     /** Value, if any. A pure flag like `pk` has `value: null`. */
     value: SettingValue | null;
+    /**
+     * True on a setting the parser added rather than read: `not null` on a
+     * primary key field of a v0.6 document (spec §10.4). Its span is the
+     * field's span.
+     */
+    implied?: true;
     span: Span;
 }
 export type SettingValue = StringValue | NumberValue | BooleanValue | NullValue | IdentifierValue | ExpressionValue | ListValue | RefValue;

package/dist/constraints.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Constraints (spec §10, new in v0.6) and referenced keys (spec §11.17).
+ *
+ * Three jobs:
+ *
+ *   1. `bodyConstraints()` / `entityConstraints()` gather every key and
+ *      check of an entity into one list, whatever form declared it: a line
+ *      in `constraints { }` or `checks { }`, `[pk]` / `[unique]` on a
+ *      field, a `pk` entry in `indexes`, a field-level `check:`. This is
+ *      the Constraint node of spec §28.6, and what the renderer and the
+ *      playground read, so a consumer finds the primary key in one place.
+ *
+ *   2. `markPrimaryKeyNotNull()` adds an implied `not null` to each
+ *      primary key field of a v0.6 document (spec §10.4). The parser calls
+ *      it once the document is built.
+ *
+ *   3. `checkConstraints()` reports the conditions of spec §10.10 and the
+ *      referenced-key rule of spec §11.17. Conditions on constructs that
+ *      earlier versions and DBML accept are errors in a document declaring
+ *      0.6 or later and warnings otherwise, so a document stays valid under
+ *      the version it declares.
+ */
+import type { EntityBodyItem, PathSegment, Span, XDbmlDocument } from './ast.ts';
+import type { Diagnostic } from './name-resolver.ts';
+/** Where a constraint was declared. The raw AST keeps the form; this list does not. */
+export type ConstraintSource = 'constraints' | 'checks' | 'inline' | 'indexes' | 'field-check';
+export interface KeyConstraint {
+    kind: 'key';
+    keyKind: 'primary' | 'unique';
+    /** Dotted field paths, in key order. */
+    fields: string[];
+    name?: string;
+    note?: string;
+    source: ConstraintSource;
+    span: Span;
+}
+export interface CheckConstraint {
+    kind: 'check';
+    expression: string;
+    name?: string;
+    note?: string;
+    /** For a field-level `check:`, the field it sits on. */
+    field?: string;
+    source: ConstraintSource;
+    span: Span;
+}
+export type Constraint = KeyConstraint | CheckConstraint;
+type Body = ReadonlyArray<EntityBodyItem>;
+/** Dotted form of a key or index path; only field segments carry names. */
+export declare function keyPathString(path: ReadonlyArray<PathSegment>): string;
+/**
+ * The constraints one body declares itself, TablePartial injections left
+ * out. `quotedFieldChecks` reads a quoted field-level `check:` as a check
+ * (v0.6 §10.5); in earlier versions a quoted value there is a string.
+ */
+export declare function bodyConstraints(body: Body, quotedFieldChecks?: boolean): Constraint[];
+/**
+ * Every constraint of an entity (or edge, or partial): its own, plus those
+ * of the TablePartials it injects. One primary key results: the entity's
+ * own when it declares one, otherwise the last injected partial's (§10.4,
+ * following the conflict resolution of §17.1).
+ */
+export declare function entityConstraints(decl: {
+    body: Body;
+}, doc: XDbmlDocument): Constraint[];
+/** The primary key of an entity, or undefined. */
+export declare function primaryKey(decl: {
+    body: Body;
+}, doc: XDbmlDocument): KeyConstraint | undefined;
+/**
+ * Add an implied `not null` to every field of the primary key of each
+ * entity, edge and partial the document declares itself, unless the field
+ * states its nullability. `null` on a primary key field is left in place
+ * for checkConstraints to report. Keys naming a partial's field from the
+ * injecting entity are not marked: the field belongs to the partial.
+ */
+export declare function markPrimaryKeyNotNull(doc: XDbmlDocument): void;
+/** True for a target name the §11.17 rule covers. Unlisted names are not relational. */
+export declare function isRelationalTarget(name: string): boolean;
+export declare function checkConstraints(doc: XDbmlDocument): Diagnostic[];
+export {};