@mateusseiboth/ember-orm 0.1.0

package/dist/index-D0xIdtCl.d.ts

@@ -0,0 +1,145 @@
+/**
+ * EmberORM schema AST (DMMF-like).
+ *
+ * This is the single in-memory source of truth that every other layer
+ * (parser, validator, query engine, generator, introspection) depends on.
+ * It is intentionally decoupled from Firebird specifics so it can be reused
+ * for other dialects in the future.
+ */
+type ScalarType = "String" | "Boolean" | "Int" | "BigInt" | "Float" | "Decimal" | "DateTime" | "Bytes" | "Json";
+declare const SCALAR_TYPES: readonly ScalarType[];
+type FieldKind = "scalar" | "enum" | "object";
+/** Value of an attribute argument, e.g. `@default(now())` or `@map("USER_ID")`. */
+type AttributeArgValue = {
+    kind: "string";
+    value: string;
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "boolean";
+    value: boolean;
+} | {
+    kind: "ref";
+    value: string;
+} | {
+    kind: "function";
+    name: string;
+    args: AttributeArgValue[];
+} | {
+    kind: "array";
+    items: AttributeArgValue[];
+};
+interface DefaultValue {
+    /** A scalar literal default. */
+    literal?: string | number | boolean;
+    /** A function default such as now(), uuid(), cuid(), autoincrement(). */
+    function?: {
+        name: string;
+        args: AttributeArgValue[];
+    };
+}
+interface RelationInfo {
+    /** Relation name (@relation("name")). */
+    name?: string;
+    /** Local fields participating in the FK (`fields: [...]`). */
+    fields?: string[];
+    /** Referenced fields on the other model (`references: [...]`). */
+    references?: string[];
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+}
+type ReferentialAction = "Cascade" | "Restrict" | "NoAction" | "SetNull" | "SetDefault";
+interface NativeType {
+    /** e.g. "VarChar", "Decimal". */
+    name: string;
+    /** e.g. [255] or [18, 4]. */
+    args: number[];
+}
+interface FieldNode {
+    name: string;
+    /** Resolved type name: a ScalarType, an enum name, or a model name. */
+    type: string;
+    kind: FieldKind;
+    isList: boolean;
+    isRequired: boolean;
+    isId: boolean;
+    isUnique: boolean;
+    isUpdatedAt: boolean;
+    /** Column name in the database (@map). Defaults to `name`. */
+    dbName?: string;
+    default?: DefaultValue;
+    relation?: RelationInfo;
+    nativeType?: NativeType;
+    /** documentation/comment attached above the field (///). */
+    documentation?: string;
+}
+interface UniqueIndex {
+    name?: string;
+    fields: string[];
+}
+interface IndexNode {
+    name?: string;
+    fields: string[];
+    unique: boolean;
+}
+interface ModelNode {
+    name: string;
+    /** Table name in the database (@@map). Defaults to `name`. */
+    dbName?: string;
+    fields: FieldNode[];
+    /** Names of fields forming the primary key (composite supported via @@id). */
+    primaryKey: string[];
+    uniqueIndexes: UniqueIndex[];
+    indexes: IndexNode[];
+    documentation?: string;
+}
+interface EnumNode {
+    name: string;
+    dbName?: string;
+    values: {
+        name: string;
+        dbName?: string;
+    }[];
+    documentation?: string;
+}
+interface DatasourceNode {
+    name: string;
+    provider: string;
+    /** Raw url expression; env("X") resolved at runtime. */
+    url: {
+        kind: "literal" | "env";
+        value: string;
+    };
+}
+interface GeneratorNode {
+    name: string;
+    provider: string;
+    output?: string;
+    config: Record<string, string>;
+}
+interface SchemaDocument {
+    datasource?: DatasourceNode;
+    generators: GeneratorNode[];
+    models: ModelNode[];
+    enums: EnumNode[];
+}
+declare function emptySchema(): SchemaDocument;
+declare function findModel(schema: SchemaDocument, name: string): ModelNode | undefined;
+declare function findEnum(schema: SchemaDocument, name: string): EnumNode | undefined;
+/**
+ * Physical column name. Firebird folds unquoted identifiers to UPPER CASE, and
+ * EmberORM always quotes identifiers, so a field without an explicit `@map`
+ * resolves to its UPPER-CASED name to match the stored column. Use `@map` to
+ * target a column created with case-sensitive (quoted) lower/mixed case.
+ */
+declare function fieldColumn(field: FieldNode): string;
+/** Physical table name; same UPPER-CASE folding rule as {@link fieldColumn}. */
+declare function modelTable(model: ModelNode): string;
+/** Returns scalar fields only (excludes relation/object fields). */
+declare function scalarFields(model: ModelNode): FieldNode[];
+/** Returns relation (object) fields only. */
+declare function relationFields(model: ModelNode): FieldNode[];
+declare function idFields(model: ModelNode): FieldNode[];
+
+export { type AttributeArgValue as A, type DatasourceNode as D, type EnumNode as E, type FieldNode as F, type GeneratorNode as G, type IndexNode as I, type ModelNode as M, type NativeType as N, type ReferentialAction as R, type SchemaDocument as S, type UniqueIndex as U, SCALAR_TYPES as a, type ScalarType as b, type DefaultValue as c, type FieldKind as d, type RelationInfo as e, emptySchema as f, fieldColumn as g, findEnum as h, findModel as i, idFields as j, modelTable as m, relationFields as r, scalarFields as s };