@mateusseiboth/ember-orm 0.1.0

package/dist/editor.js

@@ -0,0 +1,1077 @@
+// src/schema/index.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+
+// src/errors/index.ts
+var EmberError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SchemaParseError = class extends EmberError {
+  constructor(message, line, column, file) {
+    super(
+      `${message} (at ${file ? `${file}:` : ""}${line}:${column})`
+    );
+    this.line = line;
+    this.column = column;
+    this.file = file;
+  }
+  line;
+  column;
+  file;
+};
+var SchemaValidationError = class extends EmberError {
+  constructor(message, details = []) {
+    super(
+      details.length > 0 ? `${message}
+ - ${details.join("\n - ")}` : message
+    );
+    this.details = details;
+  }
+  details;
+};
+
+// src/schema/lexer.ts
+var SINGLE_CHAR_TOKENS = {
+  "{": "lbrace",
+  "}": "rbrace",
+  "(": "lparen",
+  ")": "rparen",
+  "[": "lbracket",
+  "]": "rbracket",
+  "=": "equals",
+  ",": "comma",
+  ":": "colon",
+  "?": "question",
+  ".": "dot"
+};
+var IDENT_START = /[A-Za-z_]/;
+var IDENT_PART = /[A-Za-z0-9_]/;
+var Lexer = class {
+  constructor(source, file) {
+    this.source = source;
+    this.file = file;
+  }
+  source;
+  file;
+  pos = 0;
+  line = 1;
+  column = 1;
+  tokenize() {
+    const tokens = [];
+    let token = this.next();
+    while (token.type !== "eof") {
+      tokens.push(token);
+      token = this.next();
+    }
+    tokens.push(token);
+    return tokens;
+  }
+  next() {
+    this.skipWhitespaceAndComments();
+    if (this.pos >= this.source.length) {
+      return this.make("eof", "");
+    }
+    const startLine = this.line;
+    const startColumn = this.column;
+    const ch = this.source[this.pos];
+    if (ch === "/" && this.peek(1) === "/" && this.peek(2) === "/") {
+      return this.readDocComment(startLine, startColumn);
+    }
+    if (ch === '"') {
+      return this.readString(startLine, startColumn);
+    }
+    if (ch === "@") {
+      this.advance();
+      if (this.source[this.pos] === "@") {
+        this.advance();
+        return { type: "double_at", value: "@@", line: startLine, column: startColumn };
+      }
+      return { type: "at", value: "@", line: startLine, column: startColumn };
+    }
+    const single = SINGLE_CHAR_TOKENS[ch];
+    if (single) {
+      this.advance();
+      return { type: single, value: ch, line: startLine, column: startColumn };
+    }
+    if (ch === "-" || /[0-9]/.test(ch)) {
+      return this.readNumber(startLine, startColumn);
+    }
+    if (IDENT_START.test(ch)) {
+      return this.readIdentifier(startLine, startColumn);
+    }
+    throw new SchemaParseError(
+      `Unexpected character '${ch}'`,
+      startLine,
+      startColumn,
+      this.file
+    );
+  }
+  readDocComment(line, column) {
+    this.advance();
+    this.advance();
+    this.advance();
+    let value = "";
+    while (this.pos < this.source.length && this.source[this.pos] !== "\n") {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    return { type: "doc_comment", value: value.trim(), line, column };
+  }
+  readString(line, column) {
+    this.advance();
+    let value = "";
+    while (this.pos < this.source.length && this.source[this.pos] !== '"') {
+      const c = this.source[this.pos];
+      if (c === "\\") {
+        this.advance();
+        const escaped = this.source[this.pos];
+        if (escaped === void 0) break;
+        value += escapeChar(escaped);
+        this.advance();
+        continue;
+      }
+      if (c === "\n") {
+        throw new SchemaParseError(
+          "Unterminated string literal",
+          line,
+          column,
+          this.file
+        );
+      }
+      value += c;
+      this.advance();
+    }
+    if (this.source[this.pos] !== '"') {
+      throw new SchemaParseError(
+        "Unterminated string literal",
+        line,
+        column,
+        this.file
+      );
+    }
+    this.advance();
+    return { type: "string", value, line, column };
+  }
+  readNumber(line, column) {
+    let value = "";
+    if (this.source[this.pos] === "-") {
+      value += "-";
+      this.advance();
+    }
+    while (this.pos < this.source.length && /[0-9.]/.test(this.source[this.pos])) {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    return { type: "number", value, line, column };
+  }
+  readIdentifier(line, column) {
+    let value = "";
+    while (this.pos < this.source.length && IDENT_PART.test(this.source[this.pos])) {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    return { type: "identifier", value, line, column };
+  }
+  skipWhitespaceAndComments() {
+    while (this.pos < this.source.length) {
+      const ch = this.source[this.pos];
+      if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+        this.advance();
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "/" && this.peek(2) !== "/") {
+        while (this.pos < this.source.length && this.source[this.pos] !== "\n") {
+          this.advance();
+        }
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "*") {
+        this.advance();
+        this.advance();
+        while (this.pos < this.source.length && !(this.source[this.pos] === "*" && this.peek(1) === "/")) {
+          this.advance();
+        }
+        this.advance();
+        this.advance();
+        continue;
+      }
+      break;
+    }
+  }
+  peek(offset) {
+    return this.source[this.pos + offset];
+  }
+  advance() {
+    if (this.source[this.pos] === "\n") {
+      this.line++;
+      this.column = 1;
+    } else {
+      this.column++;
+    }
+    this.pos++;
+  }
+  make(type, value) {
+    return { type, value, line: this.line, column: this.column };
+  }
+};
+function escapeChar(c) {
+  switch (c) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    case '"':
+      return '"';
+    case "\\":
+      return "\\";
+    default:
+      return c;
+  }
+}
+
+// src/schema/parser.ts
+var Parser = class {
+  constructor(source, file) {
+    this.file = file;
+    this.tokens = new Lexer(source, file).tokenize();
+  }
+  file;
+  tokens;
+  pos = 0;
+  parse() {
+    const doc = { generators: [], models: [], enums: [] };
+    let pendingDoc = [];
+    while (!this.isEof()) {
+      const tok = this.peek();
+      if (tok.type === "doc_comment") {
+        pendingDoc.push(tok.value);
+        this.advance();
+        continue;
+      }
+      if (tok.type !== "identifier") {
+        throw this.error(`Unexpected token '${tok.value}'`, tok);
+      }
+      const documentation = pendingDoc.length ? pendingDoc.join("\n") : void 0;
+      pendingDoc = [];
+      switch (tok.value) {
+        case "datasource":
+          doc.datasource = this.parseDatasource();
+          break;
+        case "generator":
+          doc.generators.push(this.parseGenerator());
+          break;
+        case "model":
+          doc.models.push(this.parseModel(documentation));
+          break;
+        case "enum":
+          doc.enums.push(this.parseEnum(documentation));
+          break;
+        default:
+          throw this.error(`Unknown top-level keyword '${tok.value}'`, tok);
+      }
+    }
+    resolveKinds(doc);
+    return doc;
+  }
+  // ---- Top-level blocks -------------------------------------------------
+  parseDatasource() {
+    this.expectKeyword("datasource");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const assignments = this.parseAssignments();
+    this.expect("rbrace");
+    const provider = literalString(assignments["provider"]);
+    const urlAssign = assignments["url"];
+    let url = { kind: "literal", value: "" };
+    if (urlAssign) {
+      if (urlAssign.kind === "function" && urlAssign.name === "env") {
+        url = { kind: "env", value: literalString(urlAssign.args[0]) };
+      } else if (urlAssign.kind === "string") {
+        url = { kind: "literal", value: urlAssign.value };
+      }
+    }
+    return { name, provider: provider ?? "firebird", url };
+  }
+  parseGenerator() {
+    this.expectKeyword("generator");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const assignments = this.parseAssignments();
+    this.expect("rbrace");
+    const config = {};
+    for (const [key, value] of Object.entries(assignments)) {
+      if (value.kind === "string") config[key] = value.value;
+    }
+    return {
+      name,
+      provider: literalString(assignments["provider"]) ?? "ember-client-js",
+      output: assignments["output"] ? literalString(assignments["output"]) : void 0,
+      config
+    };
+  }
+  parseAssignments() {
+    const out = {};
+    while (!this.check("rbrace") && !this.isEof()) {
+      if (this.check("doc_comment")) {
+        this.advance();
+        continue;
+      }
+      const key = this.expect("identifier").value;
+      this.expect("equals");
+      out[key] = this.parseValue();
+    }
+    return out;
+  }
+  parseModel(documentation) {
+    this.expectKeyword("model");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const model = {
+      name,
+      fields: [],
+      primaryKey: [],
+      uniqueIndexes: [],
+      indexes: [],
+      documentation
+    };
+    let pendingDoc = [];
+    while (!this.check("rbrace") && !this.isEof()) {
+      const tok = this.peek();
+      if (tok.type === "doc_comment") {
+        pendingDoc.push(tok.value);
+        this.advance();
+        continue;
+      }
+      if (tok.type === "double_at") {
+        this.parseBlockAttribute(model);
+        pendingDoc = [];
+        continue;
+      }
+      const field = this.parseField(
+        pendingDoc.length ? pendingDoc.join("\n") : void 0
+      );
+      pendingDoc = [];
+      model.fields.push(field);
+      if (field.isId && !model.primaryKey.includes(field.name)) {
+        model.primaryKey.push(field.name);
+      }
+    }
+    this.expect("rbrace");
+    return model;
+  }
+  parseField(documentation) {
+    const name = this.expect("identifier").value;
+    const typeName = this.expect("identifier").value;
+    let isList = false;
+    let isRequired = true;
+    while (this.check("lbracket") || this.check("question")) {
+      if (this.check("lbracket")) {
+        this.advance();
+        this.expect("rbracket");
+        isList = true;
+      } else {
+        this.advance();
+        isRequired = false;
+      }
+    }
+    const field = {
+      name,
+      type: typeName,
+      kind: "scalar",
+      // resolved later
+      isList,
+      isRequired,
+      isId: false,
+      isUnique: false,
+      isUpdatedAt: false,
+      documentation
+    };
+    while (this.check("at")) {
+      const attr = this.parseAttribute();
+      this.applyFieldAttribute(field, attr);
+    }
+    return field;
+  }
+  applyFieldAttribute(field, attr) {
+    if (attr.name.startsWith("db.")) {
+      field.nativeType = toNativeType(attr);
+      return;
+    }
+    switch (attr.name) {
+      case "id":
+        field.isId = true;
+        break;
+      case "unique":
+        field.isUnique = true;
+        break;
+      case "updatedAt":
+        field.isUpdatedAt = true;
+        break;
+      case "default":
+        field.default = toDefaultValue(attr.args[0]);
+        break;
+      case "map":
+        field.dbName = literalString(attr.args[0]);
+        break;
+      case "relation":
+        field.relation = toRelationInfo(attr.args);
+        break;
+      default:
+        throw this.error(`Unknown field attribute '@${attr.name}'`, attr);
+    }
+  }
+  parseBlockAttribute(model) {
+    const start = this.expect("double_at");
+    const name = this.expect("identifier").value;
+    const args = this.check("lparen") ? this.parseArgList() : [];
+    switch (name) {
+      case "id":
+        model.primaryKey = fieldNameList(args);
+        break;
+      case "unique":
+        model.uniqueIndexes.push({
+          fields: fieldNameList(args),
+          name: namedArg(args, "map")
+        });
+        break;
+      case "index":
+        model.indexes.push({
+          fields: fieldNameList(args),
+          name: namedArg(args, "map"),
+          unique: false
+        });
+        break;
+      case "map":
+        model.dbName = literalString(args[0]);
+        break;
+      default:
+        throw this.error(`Unknown block attribute '@@${name}'`, start);
+    }
+  }
+  parseEnum(documentation) {
+    this.expectKeyword("enum");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const node = { name, values: [], documentation };
+    while (!this.check("rbrace") && !this.isEof()) {
+      if (this.check("doc_comment")) {
+        this.advance();
+        continue;
+      }
+      if (this.check("double_at")) {
+        this.advance();
+        const attrName = this.expect("identifier").value;
+        const args = this.check("lparen") ? this.parseArgList() : [];
+        if (attrName === "map") node.dbName = literalString(args[0]);
+        continue;
+      }
+      const valueName = this.expect("identifier").value;
+      let dbName;
+      while (this.check("at")) {
+        const attr = this.parseAttribute();
+        if (attr.name === "map") dbName = literalString(attr.args[0]);
+      }
+      node.values.push({ name: valueName, dbName });
+    }
+    this.expect("rbrace");
+    return node;
+  }
+  // ---- Attributes & values ---------------------------------------------
+  parseAttribute() {
+    const at = this.expect("at");
+    let name = this.expect("identifier").value;
+    if (this.check("dot")) {
+      this.advance();
+      name += "." + this.expect("identifier").value;
+    }
+    const args = this.check("lparen") ? this.parseArgList() : [];
+    return { name, args, line: at.line, column: at.column };
+  }
+  parseArgList() {
+    this.expect("lparen");
+    const args = [];
+    while (!this.check("rparen") && !this.isEof()) {
+      args.push(this.parseArg());
+      if (this.check("comma")) this.advance();
+    }
+    this.expect("rparen");
+    return args;
+  }
+  /** Handles both positional values and `name: value` named arguments. */
+  parseArg() {
+    if (this.check("identifier") && this.peek(1)?.type === "colon") {
+      const key = this.expect("identifier").value;
+      this.expect("colon");
+      const value = this.parseValue();
+      return { kind: "function", name: `__named:${key}`, args: [value] };
+    }
+    return this.parseValue();
+  }
+  parseValue() {
+    const tok = this.peek();
+    switch (tok.type) {
+      case "string":
+        this.advance();
+        return { kind: "string", value: tok.value };
+      case "number":
+        this.advance();
+        return { kind: "number", value: Number(tok.value) };
+      case "lbracket": {
+        this.advance();
+        const items = [];
+        while (!this.check("rbracket") && !this.isEof()) {
+          items.push(this.parseValue());
+          if (this.check("comma")) this.advance();
+        }
+        this.expect("rbracket");
+        return { kind: "array", items };
+      }
+      case "identifier": {
+        this.advance();
+        if (tok.value === "true" || tok.value === "false") {
+          return { kind: "boolean", value: tok.value === "true" };
+        }
+        if (this.check("lparen")) {
+          const args = this.parseArgList();
+          return { kind: "function", name: tok.value, args };
+        }
+        return { kind: "ref", value: tok.value };
+      }
+      default:
+        throw this.error(`Unexpected value token '${tok.value}'`, tok);
+    }
+  }
+  // ---- Token helpers ----------------------------------------------------
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset] ?? this.tokens[this.tokens.length - 1];
+  }
+  advance() {
+    const tok = this.tokens[this.pos];
+    if (this.pos < this.tokens.length - 1) this.pos++;
+    return tok;
+  }
+  check(type) {
+    return this.peek().type === type;
+  }
+  isEof() {
+    return this.peek().type === "eof";
+  }
+  expect(type) {
+    const tok = this.peek();
+    if (tok.type !== type) {
+      throw this.error(`Expected ${type} but found '${tok.value}' (${tok.type})`, tok);
+    }
+    return this.advance();
+  }
+  expectKeyword(keyword) {
+    const tok = this.peek();
+    if (tok.type !== "identifier" || tok.value !== keyword) {
+      throw this.error(`Expected keyword '${keyword}'`, tok);
+    }
+    return this.advance();
+  }
+  error(message, at) {
+    return new SchemaParseError(message, at.line, at.column, this.file);
+  }
+};
+function literalString(v) {
+  if (!v) return "";
+  if (v.kind === "string") return v.value;
+  if (v.kind === "ref") return v.value;
+  return String("value" in v ? v.value : "");
+}
+function toNativeType(attr) {
+  const name = attr.name.slice("db.".length);
+  const args = attr.args.filter((a) => a.kind === "number").map((a) => a.value);
+  return { name, args };
+}
+function toDefaultValue(v) {
+  if (!v) return {};
+  switch (v.kind) {
+    case "function":
+      return { function: { name: v.name, args: v.args } };
+    case "string":
+      return { literal: v.value };
+    case "number":
+      return { literal: v.value };
+    case "boolean":
+      return { literal: v.value };
+    case "ref":
+      return { literal: v.value };
+    default:
+      return {};
+  }
+}
+function toRelationInfo(args) {
+  const info = {};
+  for (const arg of args) {
+    if (arg.kind === "string") {
+      info.name = arg.value;
+      continue;
+    }
+    const named = asNamed(arg);
+    if (!named) continue;
+    const [key, value] = named;
+    if (key === "name" && value.kind === "string") info.name = value.value;
+    if (key === "fields") info.fields = refArray(value);
+    if (key === "references") info.references = refArray(value);
+    if (key === "onDelete") info.onDelete = refName(value);
+    if (key === "onUpdate") info.onUpdate = refName(value);
+  }
+  return info;
+}
+function asNamed(arg) {
+  if (arg.kind === "function" && arg.name.startsWith("__named:")) {
+    return [arg.name.slice("__named:".length), arg.args[0]];
+  }
+  return void 0;
+}
+function namedArg(args, key) {
+  for (const arg of args) {
+    const named = asNamed(arg);
+    if (named && named[0] === key && named[1].kind === "string") {
+      return named[1].value;
+    }
+  }
+  return void 0;
+}
+function refArray(v) {
+  if (v.kind === "array") {
+    return v.items.map((i) => refName(i)).filter((s) => !!s);
+  }
+  const single = refName(v);
+  return single ? [single] : [];
+}
+function refName(v) {
+  if (v.kind === "ref") return v.value;
+  if (v.kind === "string") return v.value;
+  return void 0;
+}
+function fieldNameList(args) {
+  for (const arg of args) {
+    if (arg.kind === "array") return refArray(arg);
+    const named = asNamed(arg);
+    if (named && named[0] === "fields") return refArray(named[1]);
+  }
+  return args.map((a) => refName(a)).filter((s) => !!s);
+}
+function resolveKinds(doc) {
+  const modelNames = new Set(doc.models.map((m) => m.name));
+  const enumNames = new Set(doc.enums.map((e) => e.name));
+  for (const model of doc.models) {
+    for (const field of model.fields) {
+      if (modelNames.has(field.type)) field.kind = "object";
+      else if (enumNames.has(field.type)) field.kind = "enum";
+      else field.kind = "scalar";
+    }
+  }
+}
+
+// src/ast/index.ts
+var SCALAR_TYPES = [
+  "String",
+  "Boolean",
+  "Int",
+  "BigInt",
+  "Float",
+  "Decimal",
+  "DateTime",
+  "Bytes",
+  "Json"
+];
+function findModel(schema, name) {
+  return schema.models.find((m) => m.name === name);
+}
+function idFields(model) {
+  if (model.primaryKey.length > 0) {
+    return model.primaryKey.map((n) => model.fields.find((f) => f.name === n)).filter((f) => !!f);
+  }
+  return model.fields.filter((f) => f.isId);
+}
+
+// src/schema/validator.ts
+function validateSchema(doc) {
+  const errors = [];
+  const scalar = new Set(SCALAR_TYPES);
+  const enumNames = new Set(doc.enums.map((e) => e.name));
+  const modelNames = new Set(doc.models.map((m) => m.name));
+  const duplicateModels = findDuplicates(doc.models.map((m) => m.name));
+  for (const name of duplicateModels) {
+    errors.push(`Duplicate model '${name}'.`);
+  }
+  for (const model of doc.models) {
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (const field of model.fields) {
+      if (fieldNames.has(field.name)) {
+        errors.push(`Duplicate field '${model.name}.${field.name}'.`);
+      }
+      fieldNames.add(field.name);
+      const known = scalar.has(field.type) || enumNames.has(field.type) || modelNames.has(field.type);
+      if (!known) {
+        errors.push(
+          `Field '${model.name}.${field.name}' has unknown type '${field.type}'.`
+        );
+      }
+      if (field.kind === "object" && field.relation) {
+        validateRelation(doc, model.name, field.name, field.relation, errors);
+      }
+    }
+    for (const pk of model.primaryKey) {
+      if (!fieldNames.has(pk)) {
+        errors.push(
+          `Primary key field '${pk}' does not exist on model '${model.name}'.`
+        );
+      }
+    }
+    const hasId = model.primaryKey.length > 0 || model.fields.some((f) => f.isId);
+    if (!hasId) {
+      errors.push(
+        `Model '${model.name}' has no @id / @@id. Every model needs a primary key.`
+      );
+    }
+  }
+  for (const enumNode of doc.enums) {
+    if (enumNode.values.length === 0) {
+      errors.push(`Enum '${enumNode.name}' has no values.`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new SchemaValidationError("Schema validation failed", errors);
+  }
+}
+function validateRelation(doc, modelName, fieldName, relation, errors) {
+  const model = findModel(doc, modelName);
+  if (!model) return;
+  for (const f of relation.fields ?? []) {
+    if (!model.fields.some((mf) => mf.name === f)) {
+      errors.push(
+        `Relation '${modelName}.${fieldName}' references local field '${f}' which does not exist.`
+      );
+    }
+  }
+}
+function findDuplicates(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const dups = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    if (seen.has(v)) dups.add(v);
+    seen.add(v);
+  }
+  return [...dups];
+}
+
+// src/schema/printer.ts
+function printSchema(doc) {
+  const blocks = [];
+  if (doc.datasource) {
+    const ds = doc.datasource;
+    const url = ds.url.kind === "env" ? `env("${ds.url.value}")` : `"${ds.url.value}"`;
+    blocks.push(
+      `datasource ${ds.name} {
+  provider = "${ds.provider}"
+  url      = ${url}
+}`
+    );
+  }
+  for (const gen of doc.generators) {
+    const lines = [`  provider = "${gen.provider}"`];
+    if (gen.output) lines.push(`  output   = "${gen.output}"`);
+    for (const [k, v] of Object.entries(gen.config)) {
+      if (k === "provider" || k === "output") continue;
+      lines.push(`  ${k} = "${v}"`);
+    }
+    blocks.push(`generator ${gen.name} {
+${lines.join("\n")}
+}`);
+  }
+  for (const enumNode of doc.enums) {
+    blocks.push(printEnum(enumNode));
+  }
+  for (const model of doc.models) {
+    blocks.push(printModel(model));
+  }
+  return blocks.join("\n\n") + "\n";
+}
+function printEnum(node) {
+  const lines = [];
+  if (node.documentation) lines.push(...docLines(node.documentation));
+  lines.push(`enum ${node.name} {`);
+  for (const v of node.values) {
+    lines.push(`  ${v.name}${v.dbName ? ` @map("${v.dbName}")` : ""}`);
+  }
+  if (node.dbName) lines.push(`
+  @@map("${node.dbName}")`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function printModel(model) {
+  const lines = [];
+  if (model.documentation) lines.push(...docLines(model.documentation));
+  lines.push(`model ${model.name} {`);
+  const nameWidth = Math.max(...model.fields.map((f) => f.name.length), 0);
+  const typeWidth = Math.max(...model.fields.map((f) => fieldType(f).length), 0);
+  for (const field of model.fields) {
+    if (field.documentation) {
+      lines.push(...docLines(field.documentation).map((l) => `  ${l}`));
+    }
+    const attrs = fieldAttributes(field);
+    const name = field.name.padEnd(nameWidth);
+    const type = fieldType(field).padEnd(typeWidth);
+    lines.push(`  ${name} ${type}${attrs ? ` ${attrs}` : ""}`.trimEnd());
+  }
+  const blockAttrs = modelBlockAttributes(model);
+  if (blockAttrs.length > 0) {
+    lines.push("");
+    for (const a of blockAttrs) lines.push(`  ${a}`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function fieldType(field) {
+  let t = field.type;
+  if (field.isList) t += "[]";
+  else if (!field.isRequired) t += "?";
+  return t;
+}
+function fieldAttributes(field) {
+  const parts = [];
+  if (field.isId) parts.push("@id");
+  if (field.isUnique) parts.push("@unique");
+  if (field.default) parts.push(`@default(${printDefault(field.default)})`);
+  if (field.isUpdatedAt) parts.push("@updatedAt");
+  if (field.relation) {
+    const rel = field.relation;
+    const args = [];
+    if (rel.name) args.push(`"${rel.name}"`);
+    if (rel.fields?.length) args.push(`fields: [${rel.fields.join(", ")}]`);
+    if (rel.references?.length)
+      args.push(`references: [${rel.references.join(", ")}]`);
+    if (rel.onDelete) args.push(`onDelete: ${rel.onDelete}`);
+    if (rel.onUpdate) args.push(`onUpdate: ${rel.onUpdate}`);
+    parts.push(args.length ? `@relation(${args.join(", ")})` : "@relation");
+  }
+  if (field.nativeType) {
+    const a = field.nativeType.args.length ? `(${field.nativeType.args.join(", ")})` : "";
+    parts.push(`@db.${field.nativeType.name}${a}`);
+  }
+  if (field.dbName) parts.push(`@map("${field.dbName}")`);
+  return parts.join(" ");
+}
+function printDefault(def) {
+  if (def.function) {
+    return `${def.function.name}(${def.function.args.map(printArgValue).join(", ")})`;
+  }
+  if (typeof def.literal === "string") {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(def.literal) ? def.literal : `"${def.literal}"`;
+  }
+  return String(def.literal);
+}
+function printArgValue(v) {
+  switch (v.kind) {
+    case "string":
+      return `"${v.value}"`;
+    case "number":
+      return String(v.value);
+    case "boolean":
+      return String(v.value);
+    case "ref":
+      return v.value;
+    case "array":
+      return `[${v.items.map(printArgValue).join(", ")}]`;
+    case "function":
+      return `${v.name}(${v.args.map(printArgValue).join(", ")})`;
+  }
+}
+function modelBlockAttributes(model) {
+  const out = [];
+  const inlineId = model.primaryKey.length === 1 && model.fields.find((f) => f.name === model.primaryKey[0])?.isId;
+  if (model.primaryKey.length > 0 && !inlineId) {
+    out.push(`@@id([${model.primaryKey.join(", ")}])`);
+  }
+  for (const u of model.uniqueIndexes) {
+    out.push(
+      `@@unique([${u.fields.join(", ")}]${u.name ? `, map: "${u.name}"` : ""})`
+    );
+  }
+  for (const i of model.indexes) {
+    out.push(
+      `@@index([${i.fields.join(", ")}]${i.name ? `, map: "${i.name}"` : ""})`
+    );
+  }
+  if (model.dbName) out.push(`@@map("${model.dbName}")`);
+  return out;
+}
+function docLines(documentation) {
+  return documentation.split("\n").map((l) => `/// ${l}`);
+}
+
+// src/utils/index.ts
+function pascalCase(input) {
+  return input.toLowerCase().replace(
+    /[^a-zA-Z0-9]+(.)?/g,
+    (_, c) => c ? c.toUpperCase() : ""
+  ).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function camelCase(input) {
+  const pascal = pascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function pluralize(word) {
+  if (/[^aeiou]y$/i.test(word)) return word.replace(/y$/i, "ies");
+  if (/(s|x|z|ch|sh)$/i.test(word)) return `${word}es`;
+  return `${word}s`;
+}
+
+// src/schema/relations-complete.ts
+function completeRelations(doc) {
+  const original = [];
+  for (const model of doc.models) {
+    for (const field of model.fields) {
+      if (field.kind === "object") original.push({ model, field });
+    }
+  }
+  for (const { model, field } of original) {
+    const related = findModel(doc, field.type);
+    if (!related) continue;
+    if (hasPartner(related, model, field)) continue;
+    if (field.isList) {
+      addOwningSide(related, model, field);
+    } else if (field.relation?.fields?.length) {
+      addBackRelation(related, model, field);
+    } else {
+      upgradeBareToOne(doc, model, field);
+    }
+  }
+  return doc;
+}
+function hasPartner(related, model, field) {
+  return related.fields.some(
+    (f) => f !== field && f.kind === "object" && f.type === model.name && relationNamesMatch(f, field)
+  );
+}
+function relationNamesMatch(a, b) {
+  const an = a.relation?.name;
+  const bn = b.relation?.name;
+  if (an && bn) return an === bn;
+  if (!an && !bn) return true;
+  return false;
+}
+function addBackRelation(related, owner, owning) {
+  const fkFields = (owning.relation?.fields ?? []).map((n) => owner.fields.find((f) => f.name === n)).filter((f) => !!f);
+  const isOneToOne = fkFields.length > 0 && fkFields.every((f) => f.isUnique);
+  const baseName = isOneToOne ? camelCase(owner.name) : camelCase(pluralize(owner.name));
+  const name = uniqueFieldName(related, baseName);
+  related.fields.push({
+    name,
+    type: owner.name,
+    kind: "object",
+    isList: !isOneToOne,
+    isRequired: false,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    // Only emit @relation when the relation is named; an unnamed back-relation
+    // carries no attribute (matches Prisma's formatter output).
+    ...owning.relation?.name ? { relation: { name: owning.relation.name } } : {}
+  });
+}
+function addOwningSide(related, parent, listField) {
+  const ref = idFields(parent)[0];
+  if (!ref) return;
+  const relationField = uniqueFieldName(related, camelCase(parent.name));
+  const fkName = uniqueFieldName(
+    related,
+    `${camelCase(parent.name)}${pascalCase(ref.name)}`
+  );
+  related.fields.push({
+    name: fkName,
+    type: ref.type,
+    kind: "scalar",
+    isList: false,
+    isRequired: true,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    ...ref.nativeType ? { nativeType: ref.nativeType } : {}
+  });
+  related.fields.push({
+    name: relationField,
+    type: parent.name,
+    kind: "object",
+    isList: false,
+    isRequired: true,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    relation: {
+      ...listField.relation?.name ? { name: listField.relation.name } : {},
+      fields: [fkName],
+      references: [ref.name]
+    }
+  });
+}
+function upgradeBareToOne(doc, model, field) {
+  const related = findModel(doc, field.type);
+  if (!related) return;
+  const ref = idFields(related)[0];
+  if (!ref) return;
+  const fkName = uniqueFieldName(model, `${field.name}${pascalCase(ref.name)}`);
+  const idx = model.fields.indexOf(field);
+  model.fields.splice(idx, 0, {
+    name: fkName,
+    type: ref.type,
+    kind: "scalar",
+    isList: false,
+    isRequired: field.isRequired,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    ...ref.nativeType ? { nativeType: ref.nativeType } : {}
+  });
+  field.relation = {
+    ...field.relation ?? {},
+    fields: [fkName],
+    references: [ref.name]
+  };
+  addBackRelation(related, model, field);
+}
+function uniqueFieldName(model, base) {
+  let name = base || "relation";
+  let i = 1;
+  while (model.fields.some((f) => f.name === name)) name = `${base}_${++i}`;
+  return name;
+}
+
+// src/schema/index.ts
+function formatSchema(source, file) {
+  const doc = completeRelations(parseSchema(source, file));
+  validateSchema(doc);
+  return printSchema(doc);
+}
+function parseSchema(source, file) {
+  return new Parser(source, file).parse();
+}
+function parseAndValidate(source, file) {
+  const doc = parseSchema(source, file);
+  validateSchema(doc);
+  return doc;
+}
+export {
+  EmberError,
+  SCALAR_TYPES,
+  SchemaParseError,
+  SchemaValidationError,
+  completeRelations,
+  formatSchema,
+  parseAndValidate,
+  parseSchema,
+  printSchema,
+  validateSchema
+};
+//# sourceMappingURL=editor.js.map