@vibeorm/generator 1.0.0

package/src/generators/generate-delegates.ts

@@ -0,0 +1,213 @@
+import type { Model, Schema, ScalarField, EnumField } from "@vibeorm/parser";
+import { fileHeader, toCamelCase } from "../utils.ts";
+
+const NUMERIC_PRISMA_TYPES = new Set(["Int", "Float", "Decimal", "BigInt"]);
+
+/**
+ * Generates delegate interfaces for each model.
+ * These are the user-facing APIs: db.user.findMany(), db.post.create(), etc.
+ *
+ * Each method uses a generic parameter to capture the exact literal type
+ * of the args object, enabling TypeScript to narrow the return type
+ * through the GetFindResult conditional type.
+ */
+export function generateDelegates(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Imports
+  const argsImports = schema.models
+    .flatMap((m) => [
+      `${m.name}FindManyArgs`,
+      `${m.name}FindFirstArgs`,
+      `${m.name}FindUniqueArgs`,
+      `${m.name}CreateArgs`,
+      `${m.name}CreateManyArgs`,
+      `${m.name}CreateManyAndReturnArgs`,
+      `${m.name}UpdateArgs`,
+      `${m.name}UpsertArgs`,
+      `${m.name}DeleteArgs`,
+      `${m.name}DeleteManyArgs`,
+      `${m.name}UpdateManyArgs`,
+      `${m.name}CountArgs`,
+      `${m.name}AggregateArgs`,
+      `${m.name}GroupByArgs`,
+    ])
+    .join(", ");
+  parts.push(`import type { ${argsImports} } from "./args.ts";`);
+
+  const payloadImports = schema.models
+    .map((m) => `$${m.name}Payload`)
+    .join(", ");
+  parts.push(`import type { ${payloadImports} } from "./models.ts";`);
+
+  parts.push(`import type { GetResult } from "./result.ts";`);
+
+  // Import enums if any models have enum fields
+  if (schema.enums.length > 0) {
+    const enumImports = schema.enums.map((e) => e.name).join(", ");
+    parts.push(`import type { ${enumImports} } from "./enums.ts";`);
+  }
+  parts.push("");
+
+  // Generate delegate for each model
+  for (const model of schema.models) {
+    parts.push(generateModelDelegate({ model }));
+    parts.push(generateAggregateResultType({ model }));
+    parts.push(generateGroupByResultType({ model }));
+  }
+
+  return parts.join("\n");
+}
+
+function generateModelDelegate(params: { model: Model }): string {
+  const { model } = params;
+  const p = `$${model.name}Payload`;
+
+  return `export type ${model.name}Delegate = {
+  findMany<T extends ${model.name}FindManyArgs>(
+    args?: T,
+  ): Promise<GetResult<${p}, T, "findMany">>;
+
+  findFirst<T extends ${model.name}FindFirstArgs>(
+    args?: T,
+  ): Promise<GetResult<${p}, T, "findFirst">>;
+
+  findUnique<T extends ${model.name}FindUniqueArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "findUnique">>;
+
+  findUniqueOrThrow<T extends ${model.name}FindUniqueArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "findUniqueOrThrow">>;
+
+  findFirstOrThrow<T extends ${model.name}FindFirstArgs>(
+    args?: T,
+  ): Promise<GetResult<${p}, T, "findFirstOrThrow">>;
+
+  create<T extends ${model.name}CreateArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "create">>;
+
+  createMany(
+    args: ${model.name}CreateManyArgs,
+  ): Promise<{ count: number }>;
+
+  createManyAndReturn<T extends ${model.name}CreateManyAndReturnArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "createManyAndReturn">>;
+
+  update<T extends ${model.name}UpdateArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "update">>;
+
+  upsert<T extends ${model.name}UpsertArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "upsert">>;
+
+  delete<T extends ${model.name}DeleteArgs>(
+    args: T,
+  ): Promise<GetResult<${p}, T, "delete">>;
+
+  deleteMany(
+    args?: ${model.name}DeleteManyArgs,
+  ): Promise<{ count: number }>;
+
+  updateMany(
+    args: ${model.name}UpdateManyArgs,
+  ): Promise<{ count: number }>;
+
+  count(
+    args?: ${model.name}CountArgs,
+  ): Promise<number>;
+
+  aggregate(
+    args: ${model.name}AggregateArgs,
+  ): Promise<Aggregate${model.name}Result>;
+
+  groupBy(
+    args: ${model.name}GroupByArgs,
+  ): Promise<${model.name}GroupByResult[]>;
+};
+`;
+}
+
+function generateAggregateResultType(params: { model: Model }): string {
+  const { model } = params;
+
+  const scalarFields = model.fields.filter(
+    (f): f is ScalarField => f.kind === "scalar"
+  );
+  const numericFields = scalarFields.filter(
+    (f) => NUMERIC_PRISMA_TYPES.has(f.prismaType)
+  );
+
+  const countFields = [
+    `    _all: number;`,
+    ...scalarFields.map((f) => `    ${f.name}: number;`),
+  ];
+
+  const avgFields = numericFields.map((f) => `    ${f.name}: number | null;`);
+  const sumFields = numericFields.map((f) => `    ${f.name}: number | null;`);
+  const minFields = scalarFields.map((f) => {
+    const tsType = f.tsType;
+    return `    ${f.name}: ${tsType} | null;`;
+  });
+  const maxFields = scalarFields.map((f) => {
+    const tsType = f.tsType;
+    return `    ${f.name}: ${tsType} | null;`;
+  });
+
+  return `export type Aggregate${model.name}Result = {
+  _count: number | {
+${countFields.join("\n")}
+  };
+  _avg: {
+${avgFields.length > 0 ? avgFields.join("\n") : "    [key: string]: never;"}
+  } | null;
+  _sum: {
+${sumFields.length > 0 ? sumFields.join("\n") : "    [key: string]: never;"}
+  } | null;
+  _min: {
+${minFields.join("\n")}
+  } | null;
+  _max: {
+${maxFields.join("\n")}
+  } | null;
+};
+`;
+}
+
+function generateGroupByResultType(params: { model: Model }): string {
+  const { model } = params;
+
+  const scalarFields = model.fields.filter(
+    (f): f is ScalarField => f.kind === "scalar"
+  );
+
+  // GroupBy result is a partial of scalars + aggregate fields
+  const scalarEntries = scalarFields.map((f) => {
+    const tsType = f.tsType;
+    const nullable = f.isRequired ? "" : " | null";
+    return `  ${f.name}?: ${tsType}${nullable};`;
+  });
+
+  // Also include enum fields
+  const enumEntries = model.fields
+    .filter((f) => f.kind === "enum")
+    .map((f) => {
+      if (f.kind !== "enum") return "";
+      const nullable = f.isRequired ? "" : " | null";
+      return `  ${f.name}?: ${f.enumName}${nullable};`;
+    });
+
+  return `export type ${model.name}GroupByResult = {
+${[...scalarEntries, ...enumEntries].join("\n")}
+  _count?: number | Record<string, number>;
+  _avg?: Record<string, number | null>;
+  _sum?: Record<string, number | null>;
+  _min?: Record<string, unknown>;
+  _max?: Record<string, unknown>;
+};
+`;
+}

package/src/generators/generate-enums.ts

@@ -0,0 +1,28 @@
+import type { Enum } from "@vibeorm/parser";
+import { fileHeader } from "../utils.ts";
+
+export function generateEnums(params: { enums: Enum[] }): string {
+  const { enums } = params;
+
+  if (enums.length === 0) {
+    return fileHeader() + "\nexport {};\n";
+  }
+
+  const parts: string[] = [fileHeader()];
+
+  for (const enumDef of enums) {
+    // Generate a const object (not a TS enum — objects are more flexible)
+    const values = enumDef.values
+      .map((v) => `  ${v.name}: "${v.name}" as const`)
+      .join(",\n");
+
+    parts.push(`export const ${enumDef.name} = {
+${values},
+} as const;
+
+export type ${enumDef.name} = (typeof ${enumDef.name})[keyof typeof ${enumDef.name}];
+`);
+  }
+
+  return parts.join("\n");
+}