@vibeorm/parser 1.0.0

package/src/parser.ts

@@ -0,0 +1,688 @@
+import { getSchema } from "@mrleebo/prisma-ast";
+import type {
+  Schema,
+  Model,
+  Field,
+  ScalarField,
+  EnumField,
+  RelationField,
+  RelationInfo,
+  RelationType,
+  PrimaryKey,
+  UniqueConstraint,
+  IndexDefinition,
+  Enum,
+  EnumValue,
+  DefaultValue,
+  PrismaScalarType,
+} from "./types.ts";
+import { PRISMA_TO_TS, PRISMA_TO_PG } from "./types.ts";
+
+// ─── prisma-ast type helpers ──────────────────────────────────────
+
+type AstSchema = ReturnType<typeof getSchema>;
+type AstBlock = AstSchema["list"][number];
+type AstModel = Extract<AstBlock, { type: "model" }>;
+type AstEnum = Extract<AstBlock, { type: "enum" }>;
+type AstProperty = AstModel["properties"][number];
+type AstField = Extract<AstProperty, { type: "field" }>;
+type AstAttribute = NonNullable<AstField["attributes"]>[number];
+type AstAttributeArg = NonNullable<AstAttribute["args"]>[number];
+
+const PRISMA_SCALAR_TYPES = new Set<string>([
+  "String",
+  "Boolean",
+  "Int",
+  "BigInt",
+  "Float",
+  "Decimal",
+  "DateTime",
+  "Json",
+  "Bytes",
+]);
+
+// ─── Public API ───────────────────────────────────────────────────
+
+export function parsePrismaSchema(params: { source: string }): Schema {
+  const { source } = params;
+  const ast = getSchema(source);
+
+  // Collect enum names for field type resolution
+  const enumNames = new Set<string>();
+  for (const block of ast.list) {
+    if (block.type === "enum") {
+      enumNames.add(block.name);
+    }
+  }
+
+  // Collect model names for relation resolution
+  const modelNames = new Set<string>();
+  for (const block of ast.list) {
+    if (block.type === "model") {
+      modelNames.add(block.name);
+    }
+  }
+
+  // First pass: parse all models with raw fields
+  const rawModels = new Map<string, { ast: AstModel; fields: AstField[] }>();
+  for (const block of ast.list) {
+    if (block.type === "model") {
+      const fields = block.properties.filter(
+        (p): p is AstField => p.type === "field"
+      );
+      rawModels.set(block.name, { ast: block, fields });
+    }
+  }
+
+  // Second pass: resolve relations and build IR models
+  const models: Model[] = [];
+  for (const [modelName, { ast: modelAst, fields }] of rawModels) {
+    models.push(
+      buildModel({
+        modelAst,
+        fields,
+        enumNames,
+        modelNames,
+        allModels: rawModels,
+      })
+    );
+  }
+
+  // Parse enums
+  const enums: Enum[] = [];
+  for (const block of ast.list) {
+    if (block.type === "enum") {
+      enums.push(buildEnum({ enumAst: block }));
+    }
+  }
+
+  return { models, enums };
+}
+
+// ─── Model Builder ────────────────────────────────────────────────
+
+function buildModel(params: {
+  modelAst: AstModel;
+  fields: AstField[];
+  enumNames: Set<string>;
+  modelNames: Set<string>;
+  allModels: Map<string, { ast: AstModel; fields: AstField[] }>;
+}): Model {
+  const { modelAst, fields, enumNames, modelNames, allModels } = params;
+
+  const blockAttrs = modelAst.properties.filter(
+    (p): p is Extract<AstProperty, { type: "attribute" }> =>
+      p.type === "attribute"
+  );
+
+  const dbName = extractBlockMap({ blockAttrs }) ?? modelAst.name;
+  const primaryKey = extractPrimaryKey({ fields, blockAttrs });
+  const uniqueConstraints = extractUniqueConstraints({ blockAttrs });
+  const indexes = extractIndexes({ blockAttrs });
+
+  const irFields: Field[] = [];
+
+  // Build a map of field name → preceding documentation comments (///)
+  // Comments appear as separate nodes before the field they document
+  const fieldDocs = new Map<string, string>();
+  const props = modelAst.properties;
+  let pendingComment: string | undefined;
+  for (const prop of props) {
+    if (prop.type === "comment") {
+      const text = (prop as { text: string }).text;
+      if (text.startsWith("///")) {
+        const line = text.slice(3).trim();
+        pendingComment = pendingComment ? `${pendingComment}\n${line}` : line;
+      }
+    } else {
+      if (pendingComment && prop.type === "field") {
+        fieldDocs.set(prop.name, pendingComment);
+      }
+      pendingComment = undefined;
+    }
+  }
+
+  for (const field of fields) {
+    const fieldType =
+      typeof field.fieldType === "string"
+        ? field.fieldType
+        : (field.fieldType as { name: string }).name;
+    const documentation = fieldDocs.get(field.name);
+
+    if (PRISMA_SCALAR_TYPES.has(fieldType)) {
+      irFields.push(buildScalarField({ field, fieldType, primaryKey, documentation }));
+    } else if (enumNames.has(fieldType)) {
+      irFields.push(buildEnumField({ field, fieldType, primaryKey, documentation }));
+    } else if (modelNames.has(fieldType)) {
+      irFields.push(
+        buildRelationField({
+          field,
+          fieldType,
+          modelName: modelAst.name,
+          allModels,
+        })
+      );
+    }
+    // Skip Unsupported types
+  }
+
+  return {
+    name: modelAst.name,
+    dbName,
+    fields: irFields,
+    primaryKey,
+    uniqueConstraints,
+    indexes,
+  };
+}
+
+// ─── Scalar Field Builder ─────────────────────────────────────────
+
+function buildScalarField(params: {
+  field: AstField;
+  fieldType: string;
+  primaryKey: PrimaryKey;
+  documentation?: string;
+}): ScalarField {
+  const { field, fieldType, primaryKey, documentation } = params;
+  const prismaType = fieldType as PrismaScalarType;
+  const attrs = field.attributes ?? [];
+
+  const hasId = attrs.some((a) => a.name === "id");
+  const hasUnique = attrs.some((a) => a.name === "unique");
+  const hasUpdatedAt = attrs.some((a) => a.name === "updatedAt");
+  const defaultValue = extractDefault({ attrs });
+  const nativeType = extractNativeType({ attrs });
+  const mapName = extractFieldMap({ attrs });
+
+  // A field is an ID if it has @id or is part of @@id
+  const isId = hasId || (primaryKey.fields.length > 0 && primaryKey.fields.includes(field.name));
+
+  return {
+    kind: "scalar",
+    name: field.name,
+    dbName: mapName ?? field.name,
+    prismaType,
+    tsType: PRISMA_TO_TS[prismaType],
+    pgType: PRISMA_TO_PG[prismaType],
+    isRequired: !field.optional,
+    isList: field.array ?? false,
+    isId,
+    isUnique: hasUnique,
+    isUpdatedAt: hasUpdatedAt,
+    default: defaultValue,
+    nativeType,
+    documentation,
+  };
+}
+
+// ─── Enum Field Builder ───────────────────────────────────────────
+
+function buildEnumField(params: {
+  field: AstField;
+  fieldType: string;
+  primaryKey: PrimaryKey;
+  documentation?: string;
+}): EnumField {
+  const { field, fieldType, primaryKey, documentation } = params;
+  const attrs = field.attributes ?? [];
+
+  const hasId = attrs.some((a) => a.name === "id");
+  const hasUnique = attrs.some((a) => a.name === "unique");
+  const defaultValue = extractDefault({ attrs });
+  const mapName = extractFieldMap({ attrs });
+  const isId = hasId || primaryKey.fields.includes(field.name);
+
+  return {
+    kind: "enum",
+    name: field.name,
+    dbName: mapName ?? field.name,
+    enumName: fieldType,
+    isRequired: !field.optional,
+    isList: field.array ?? false,
+    isId,
+    isUnique: hasUnique,
+    default: defaultValue,
+    documentation,
+  };
+}
+
+// ─── Relation Field Builder ───────────────────────────────────────
+
+function buildRelationField(params: {
+  field: AstField;
+  fieldType: string;
+  modelName: string;
+  allModels: Map<string, { ast: AstModel; fields: AstField[] }>;
+}): RelationField {
+  const { field, fieldType, modelName, allModels } = params;
+  const attrs = field.attributes ?? [];
+
+  const relationAttr = attrs.find((a) => a.name === "relation");
+  const relationName = extractRelationName({ relationAttr });
+  const relationFields = extractRelationArrayArg({
+    relationAttr,
+    key: "fields",
+  });
+  const relationReferences = extractRelationArrayArg({
+    relationAttr,
+    key: "references",
+  });
+
+  const isList = field.array ?? false;
+  const hasForeignKey = relationFields.length > 0;
+
+  // Determine relation type
+  const relationType = resolveRelationType({
+    isList,
+    isOptional: field.optional ?? false,
+    hasForeignKey,
+    relatedModelName: fieldType,
+    currentModelName: modelName,
+    allModels,
+    fieldName: field.name,
+    relationName,
+  });
+
+  const relation: RelationInfo = {
+    name: relationName,
+    fields: relationFields,
+    references: relationReferences,
+    relatedModel: fieldType,
+    type: relationType,
+    isForeignKey: hasForeignKey,
+  };
+
+  return {
+    kind: "relation",
+    name: field.name,
+    relatedModel: fieldType,
+    isList,
+    isRequired: !field.optional,
+    relation,
+  };
+}
+
+// ─── Relation Type Resolution ─────────────────────────────────────
+
+function resolveRelationType(params: {
+  isList: boolean;
+  isOptional: boolean;
+  hasForeignKey: boolean;
+  relatedModelName: string;
+  currentModelName: string;
+  allModels: Map<string, { ast: AstModel; fields: AstField[] }>;
+  fieldName: string;
+  relationName: string | undefined;
+}): RelationType {
+  const { isList, hasForeignKey, relatedModelName, allModels, relationName } =
+    params;
+
+  // If it's a list (Post[]), check if the other side is also a list with no FK (M:N)
+  if (isList) {
+    // Must not have FK on this side (implicit M:N has no fields/references)
+    if (!hasForeignKey) {
+      const relatedModel = allModels.get(relatedModelName);
+      if (relatedModel) {
+        const backRef = relatedModel.fields.find((f) => {
+          // Skip the current field itself (for self-referential models)
+          if (relatedModelName === params.currentModelName && f.name === params.fieldName) return false;
+          const ft =
+            typeof f.fieldType === "string"
+              ? f.fieldType
+              : (f.fieldType as { name: string }).name;
+          if (ft !== params.currentModelName) return false;
+          if (!(f.array ?? false)) return false;
+          // The back-ref must also have no FK (no fields/references in @relation)
+          const relAttr = (f.attributes ?? []).find(
+            (a) => a.name === "relation"
+          );
+          const backRefFields = extractRelationArrayArg({ relationAttr: relAttr, key: "fields" });
+          if (backRefFields.length > 0) return false;
+          // Match by relation name if available
+          if (relationName) {
+            const backRelName = extractRelationName({ relationAttr: relAttr });
+            return backRelName === relationName;
+          }
+          return true;
+        });
+        if (backRef) return "manyToMany";
+      }
+    }
+    return "oneToMany";
+  }
+
+  // If this side holds the FK, it's the "many" side of a manyToOne
+  // or the non-owning side of a oneToOne
+  if (hasForeignKey) {
+    // Check if the related model's back-reference is also singular (1:1) or list (1:N)
+    const relatedModel = allModels.get(relatedModelName);
+    if (relatedModel) {
+      const backRef = relatedModel.fields.find((f) => {
+        const ft =
+          typeof f.fieldType === "string"
+            ? f.fieldType
+            : (f.fieldType as { name: string }).name;
+        if (ft !== params.currentModelName) return false;
+        // Match by relation name if available
+        if (relationName) {
+          const relAttr = (f.attributes ?? []).find(
+            (a) => a.name === "relation"
+          );
+          const backRelName = extractRelationName({ relationAttr: relAttr });
+          return backRelName === relationName;
+        }
+        return true;
+      });
+
+      if (backRef && !(backRef.array ?? false)) {
+        // Back-reference is singular → this is a 1:1 where we hold the FK
+        return "oneToOne";
+      }
+    }
+    // Default: this side holds FK and the other side is a list → manyToOne
+    return "manyToOne";
+  }
+
+  // No FK on this side, not a list → oneToOne (the side without FK)
+  return "oneToOne";
+}
+
+// ─── Attribute Extraction Helpers ─────────────────────────────────
+
+function extractDefault(params: {
+  attrs: AstAttribute[];
+}): DefaultValue | undefined {
+  const { attrs } = params;
+  const defaultAttr = attrs.find((a) => a.name === "default");
+  if (!defaultAttr || !defaultAttr.args || defaultAttr.args.length === 0)
+    return undefined;
+
+  const arg = defaultAttr.args[0]!;
+  const value = arg.value;
+
+  // Function call: autoincrement(), now(), uuid(), cuid(), etc.
+  if (typeof value === "object" && value !== null && "type" in value) {
+    const obj = value as { type: string; name?: string; params?: string };
+    if (obj.type === "function") {
+      const funcName = obj.name ?? "";
+      switch (funcName) {
+        case "autoincrement":
+          return { kind: "autoincrement" };
+        case "now":
+          return { kind: "now" };
+        case "uuid":
+          return { kind: "uuid" };
+        case "cuid":
+          return { kind: "cuid" };
+        case "nanoid":
+          return { kind: "nanoid" };
+        case "ulid":
+          return { kind: "ulid" };
+        case "dbgenerated":
+          return {
+            kind: "dbgenerated",
+            value: obj.params ?? "",
+          };
+        default:
+          return { kind: "dbgenerated", value: funcName };
+      }
+    }
+  }
+
+  // Literal value
+  if (typeof value === "string") {
+    if (value === "true") return { kind: "literal", value: true };
+    if (value === "false") return { kind: "literal", value: false };
+    const num = Number(value);
+    if (!isNaN(num)) return { kind: "literal", value: num };
+    // String literal (may have quotes)
+    const cleaned = value.replace(/^"(.*)"$/, "$1");
+    return { kind: "literal", value: cleaned };
+  }
+  if (typeof value === "number") {
+    return { kind: "literal", value };
+  }
+  if (typeof value === "boolean") {
+    return { kind: "literal", value };
+  }
+
+  return undefined;
+}
+
+function extractNativeType(params: {
+  attrs: AstAttribute[];
+}): string | undefined {
+  const { attrs } = params;
+  const dbAttr = attrs.find((a) => a.group === "db");
+  if (!dbAttr) return undefined;
+  return dbAttr.name;
+}
+
+function extractFieldMap(params: {
+  attrs: AstAttribute[];
+}): string | undefined {
+  const { attrs } = params;
+  const mapAttr = attrs.find((a) => a.name === "map");
+  if (!mapAttr || !mapAttr.args || mapAttr.args.length === 0) return undefined;
+  const val = mapAttr.args[0]!.value;
+  if (typeof val === "string") {
+    return val.replace(/^"(.*)"$/, "$1");
+  }
+  return undefined;
+}
+
+function extractBlockMap(params: {
+  blockAttrs: Array<Extract<AstProperty, { type: "attribute" }>>;
+}): string | undefined {
+  const { blockAttrs } = params;
+  const mapAttr = blockAttrs.find((a) => a.name === "map");
+  if (!mapAttr || !("args" in mapAttr)) return undefined;
+  const args = (mapAttr as { args?: AstAttributeArg[] }).args;
+  if (!args || args.length === 0) return undefined;
+  const val = args[0]!.value;
+  if (typeof val === "string") {
+    return val.replace(/^"(.*)"$/, "$1");
+  }
+  return undefined;
+}
+
+function extractRelationName(params: {
+  relationAttr: AstAttribute | undefined;
+}): string | undefined {
+  const { relationAttr } = params;
+  if (!relationAttr || !relationAttr.args) return undefined;
+
+  // Relation name is the first positional (non-keyValue) argument
+  for (const arg of relationAttr.args) {
+    if (typeof arg.value === "string") {
+      return arg.value.replace(/^"(.*)"$/, "$1");
+    }
+  }
+  return undefined;
+}
+
+function extractRelationArrayArg(params: {
+  relationAttr: AstAttribute | undefined;
+  key: string;
+}): string[] {
+  const { relationAttr, key } = params;
+  if (!relationAttr || !relationAttr.args) return [];
+
+  for (const arg of relationAttr.args) {
+    const val = arg.value;
+    if (
+      typeof val === "object" &&
+      val !== null &&
+      "type" in val &&
+      (val as { type: string }).type === "keyValue"
+    ) {
+      const kv = val as { key: string; value: unknown };
+      if (kv.key === key) {
+        const arrValue = kv.value as { type: string; args: string[] };
+        if (arrValue.type === "array") {
+          return arrValue.args;
+        }
+      }
+    }
+  }
+  return [];
+}
+
+// ─── Primary Key Extraction ───────────────────────────────────────
+
+function extractPrimaryKey(params: {
+  fields: AstField[];
+  blockAttrs: Array<Extract<AstProperty, { type: "attribute" }>>;
+}): PrimaryKey {
+  const { fields, blockAttrs } = params;
+
+  // Check for @@id([field1, field2])
+  const compositeId = blockAttrs.find((a) => a.name === "id");
+  if (compositeId && "args" in compositeId) {
+    const args = (compositeId as { args?: AstAttributeArg[] }).args;
+    if (args && args.length > 0) {
+      const firstArg = args[0]!.value;
+      if (
+        typeof firstArg === "object" &&
+        firstArg !== null &&
+        "type" in firstArg
+      ) {
+        const arr = firstArg as { type: string; args: string[] };
+        if (arr.type === "array") {
+          return { fields: arr.args, isComposite: true };
+        }
+      }
+    }
+  }
+
+  // Check for @id on individual fields
+  for (const field of fields) {
+    if (field.attributes?.some((a) => a.name === "id")) {
+      return { fields: [field.name], isComposite: false };
+    }
+  }
+
+  // Fallback — no explicit primary key
+  return { fields: [], isComposite: false };
+}
+
+// ─── Unique Constraint Extraction ─────────────────────────────────
+
+function extractUniqueConstraints(params: {
+  blockAttrs: Array<Extract<AstProperty, { type: "attribute" }>>;
+}): UniqueConstraint[] {
+  const { blockAttrs } = params;
+  const constraints: UniqueConstraint[] = [];
+
+  for (const attr of blockAttrs) {
+    if (attr.name !== "unique" || !("args" in attr)) continue;
+    const args = (attr as { args?: AstAttributeArg[] }).args;
+    if (!args || args.length === 0) continue;
+
+    const firstArg = args[0]!.value;
+    if (
+      typeof firstArg === "object" &&
+      firstArg !== null &&
+      "type" in firstArg
+    ) {
+      const arr = firstArg as { type: string; args: string[] };
+      if (arr.type === "array") {
+        // Check for a name argument
+        let name: string | undefined;
+        if (args.length > 1) {
+          const nameArg = args.find((a) => {
+            const v = a.value;
+            return (
+              typeof v === "object" &&
+              v !== null &&
+              "type" in v &&
+              (v as { type: string }).type === "keyValue" &&
+              (v as { key: string }).key === "name"
+            );
+          });
+          if (nameArg) {
+            const kv = nameArg.value as { value: string };
+            name = typeof kv.value === "string" ? kv.value.replace(/^"(.*)"$/, "$1") : undefined;
+          }
+        }
+
+        constraints.push({ fields: arr.args, name });
+      }
+    }
+  }
+
+  return constraints;
+}
+
+// ─── Index Extraction ─────────────────────────────────────────────
+
+function extractIndexes(params: {
+  blockAttrs: Array<Extract<AstProperty, { type: "attribute" }>>;
+}): IndexDefinition[] {
+  const { blockAttrs } = params;
+  const indexes: IndexDefinition[] = [];
+
+  for (const attr of blockAttrs) {
+    if (attr.name !== "index" || !("args" in attr)) continue;
+    const args = (attr as { args?: AstAttributeArg[] }).args;
+    if (!args || args.length === 0) continue;
+
+    const firstArg = args[0]!.value;
+    if (
+      typeof firstArg === "object" &&
+      firstArg !== null &&
+      "type" in firstArg
+    ) {
+      const arr = firstArg as { type: string; args: string[] };
+      if (arr.type === "array") {
+        indexes.push({ fields: arr.args, name: undefined });
+      }
+    }
+  }
+
+  return indexes;
+}
+
+// ─── Enum Builder ─────────────────────────────────────────────────
+
+function buildEnum(params: { enumAst: AstEnum }): Enum {
+  const { enumAst } = params;
+
+  const values: EnumValue[] = [];
+  let enumDbName: string | undefined;
+
+  for (const entry of enumAst.enumerators) {
+    if (entry.type === "enumerator") {
+      // Extract @map("db_value") from enumerator-level attributes
+      const attrs = (entry as { attributes?: AstAttribute[] }).attributes ?? [];
+      const mapAttr = attrs.find((a) => a.name === "map");
+      let dbName: string | undefined;
+      if (mapAttr?.args && mapAttr.args.length > 0) {
+        const val = mapAttr.args[0]!.value;
+        if (typeof val === "string") {
+          dbName = val.replace(/^"(.*)"$/, "$1");
+        }
+      }
+      values.push({
+        name: entry.name,
+        dbName,
+      });
+    } else if (entry.type === "attribute") {
+      // Block-level @@map("db_name") appears as a BlockAttribute in enumerators
+      const blockAttr = entry as { name: string; args?: AstAttributeArg[] };
+      if (blockAttr.name === "map" && blockAttr.args && blockAttr.args.length > 0) {
+        const val = blockAttr.args[0]!.value;
+        if (typeof val === "string") {
+          enumDbName = val.replace(/^"(.*)"$/, "$1");
+        }
+      }
+    }
+  }
+
+  return {
+    name: enumAst.name,
+    dbName: enumDbName,
+    values,
+  };
+}