@vibeorm/generator 1.3.0 → 2.0.0-alpha.1

package/src/generators/generate-args.ts

@@ -1,322 +0,0 @@
-import type { Model, Schema, RelationField, ScalarField } from "@vibeorm/parser";
-import { fileHeader } from "../utils.ts";
-
-/**
- * Generates Select, Include, and Args types for each model,
- * plus the FindManyArgs, FindFirstArgs, FindUniqueArgs, etc.
- */
-export function generateArgs(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Imports
-  const modelImports = schema.models.map((m) => `${m.name}WhereInput, ${m.name}WhereUniqueInput, ${m.name}OrderByInput, ${m.name}CreateInput, ${m.name}UpdateInput`).join(", ");
-  parts.push(`import type { ${modelImports}, SortOrder, SortOrderWithNulls } from "./inputs.ts";`);
-
-  const payloadImports = schema.models.map((m) => `$${m.name}Payload`).join(", ");
-  parts.push(`import type { ${payloadImports}, OperationPayload } from "./models.ts";\n`);
-
-  // Shared types
-  parts.push(`export type RelationStrategy = "query" | "join";
-
-export type NumberWithAggregatesFilter = {
-  equals?: number;
-  not?: number;
-  lt?: number;
-  lte?: number;
-  gt?: number;
-  gte?: number;
-};
-`);
-
-  // Generate Select + Include + Args for each model
-  for (const model of schema.models) {
-    parts.push(generateSelectType({ model, schema }));
-    parts.push(generateIncludeType({ model, schema }));
-    parts.push(generateOperationArgs({ model }));
-    parts.push(generateAggregateInputTypes({ model }));
-  }
-
-  return parts.join("\n");
-}
-
-// ─── Select Type ──────────────────────────────────────────────────
-
-function generateSelectType(params: {
-  model: Model;
-  schema: Schema;
-}): string {
-  const { model, schema } = params;
-
-  const entries: string[] = [];
-
-  for (const field of model.fields) {
-    if (field.kind === "scalar" || field.kind === "enum") {
-      entries.push(`  ${field.name}?: boolean;`);
-    } else if (field.kind === "relation") {
-      if (field.isList) {
-        entries.push(`  ${field.name}?: boolean | ${field.relatedModel}FindManyArgs;`);
-      } else {
-        entries.push(`  ${field.name}?: boolean | ${field.relatedModel}FindFirstArgs;`);
-      }
-    }
-  }
-
-  // Add _count support for relation counting
-  const countableRelations = model.fields.filter(
-    (f): f is RelationField => f.kind === "relation" && f.isList
-  );
-  if (countableRelations.length > 0) {
-    const countFields = countableRelations.map((f) => `    ${f.name}?: boolean;`);
-    entries.push(`  _count?: boolean | {\n    select?: {\n${countFields.join("\n")}\n    };\n  };`);
-  }
-
-  return `export type ${model.name}Select = {
-${entries.join("\n")}
-};
-`;
-}
-
-// ─── Include Type ─────────────────────────────────────────────────
-
-function generateIncludeType(params: {
-  model: Model;
-  schema: Schema;
-}): string {
-  const { model } = params;
-
-  const relationFields = model.fields.filter(
-    (f): f is RelationField => f.kind === "relation"
-  );
-
-  if (relationFields.length === 0) {
-    return `export type ${model.name}Include = Record<string, never>;\n`;
-  }
-
-  const entries = relationFields.map((f) => {
-    if (f.isList) {
-      return `  ${f.name}?: boolean | ${f.relatedModel}FindManyArgs;`;
-    }
-    return `  ${f.name}?: boolean | ${f.relatedModel}FindFirstArgs;`;
-  });
-
-  // Add _count support for relation counting
-  const countableRelations = relationFields.filter((f) => f.isList);
-  if (countableRelations.length > 0) {
-    const countFields = countableRelations.map((f) => `    ${f.name}?: boolean;`);
-    entries.push(`  _count?: boolean | {\n    select?: {\n${countFields.join("\n")}\n    };\n  };`);
-  }
-
-  return `export type ${model.name}Include = {
-${entries.join("\n")}
-};
-`;
-}
-
-// ─── Operation Args ───────────────────────────────────────────────
-
-function generateOperationArgs(params: { model: Model }): string {
-  const { model } = params;
-
-  // Omit type — inverse of select (exclude specific fields)
-  const scalarFieldNames = model.fields
-    .filter((f) => f.kind === "scalar" || f.kind === "enum")
-    .map((f) => `  ${f.name}?: boolean;`);
-
-  const omitTypeDef = `export type ${model.name}Omit = {
-${scalarFieldNames.join("\n")}
-};
-`;
-
-  return `${omitTypeDef}
-export type ${model.name}FindManyArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-  distinct?: (keyof ${model.name}Select)[];
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}FindFirstArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}FindUniqueArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where: ${model.name}WhereUniqueInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}CreateArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  data: ${model.name}CreateInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}UpdateArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  omit?: ${model.name}Omit;
-  where: ${model.name}WhereUniqueInput;
-  data: ${model.name}UpdateInput;
-  relationStrategy?: RelationStrategy;
-};
-
-export type ${model.name}UpsertArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  where: ${model.name}WhereUniqueInput;
-  create: ${model.name}CreateInput;
-  update: ${model.name}UpdateInput;
-};
-
-export type ${model.name}DeleteArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  where: ${model.name}WhereUniqueInput;
-};
-
-export type ${model.name}DeleteManyArgs = {
-  where?: ${model.name}WhereInput;
-};
-
-export type ${model.name}CountArgs = {
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-};
-
-export type ${model.name}CreateManyArgs = {
-  data: ${model.name}CreateInput | ${model.name}CreateInput[];
-  skipDuplicates?: boolean;
-};
-
-export type ${model.name}CreateManyAndReturnArgs = {
-  select?: ${model.name}Select | null;
-  include?: ${model.name}Include | null;
-  data: ${model.name}CreateInput | ${model.name}CreateInput[];
-  skipDuplicates?: boolean;
-};
-
-export type ${model.name}UpdateManyArgs = {
-  where?: ${model.name}WhereInput;
-  data: ${model.name}UpdateInput;
-};
-
-export type ${model.name}AggregateArgs = {
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  take?: number;
-  skip?: number;
-  cursor?: ${model.name}WhereUniqueInput;
-  _count?: true | ${model.name}CountAggregateInputType;
-  _avg?: ${model.name}AvgAggregateInputType;
-  _sum?: ${model.name}SumAggregateInputType;
-  _min?: ${model.name}MinAggregateInputType;
-  _max?: ${model.name}MaxAggregateInputType;
-};
-
-export type ${model.name}GroupByArgs = {
-  by: (keyof ${model.name}Select)[];
-  where?: ${model.name}WhereInput;
-  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];
-  having?: ${model.name}ScalarWhereWithAggregatesInput;
-  take?: number;
-  skip?: number;
-  _count?: true | ${model.name}CountAggregateInputType;
-  _avg?: ${model.name}AvgAggregateInputType;
-  _sum?: ${model.name}SumAggregateInputType;
-  _min?: ${model.name}MinAggregateInputType;
-  _max?: ${model.name}MaxAggregateInputType;
-};
-`;
-}
-
-// ─── Aggregate Input Types ────────────────────────────────────────
-
-const NUMERIC_PRISMA_TYPES = new Set(["Int", "Float", "Decimal", "BigInt"]);
-
-function generateAggregateInputTypes(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)
-  );
-
-  // CountAggregateInputType — all scalar fields + _all
-  const countEntries = [
-    `  _all?: boolean;`,
-    ...scalarFields.map((f) => `  ${f.name}?: boolean;`),
-  ];
-
-  // AvgAggregateInputType — only numeric fields
-  const avgEntries = numericFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // SumAggregateInputType — only numeric fields
-  const sumEntries = numericFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // MinAggregateInputType — all scalar fields
-  const minEntries = scalarFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // MaxAggregateInputType — all scalar fields
-  const maxEntries = scalarFields.map((f) => `  ${f.name}?: boolean;`);
-
-  // ScalarWhereWithAggregatesInput — for HAVING clause in groupBy
-  const havingEntries = scalarFields.map((f) => {
-    return `  ${f.name}?: {
-    _count?: NumberWithAggregatesFilter;
-    _avg?: NumberWithAggregatesFilter;
-    _sum?: NumberWithAggregatesFilter;
-    _min?: NumberWithAggregatesFilter;
-    _max?: NumberWithAggregatesFilter;
-  };`;
-  });
-
-  return `export type ${model.name}CountAggregateInputType = {
-${countEntries.join("\n")}
-};
-
-export type ${model.name}AvgAggregateInputType = {
-${avgEntries.length > 0 ? avgEntries.join("\n") : "  [key: string]: never;"}
-};
-
-export type ${model.name}SumAggregateInputType = {
-${sumEntries.length > 0 ? sumEntries.join("\n") : "  [key: string]: never;"}
-};
-
-export type ${model.name}MinAggregateInputType = {
-${minEntries.join("\n")}
-};
-
-export type ${model.name}MaxAggregateInputType = {
-${maxEntries.join("\n")}
-};
-
-export type ${model.name}ScalarWhereWithAggregatesInput = {
-${havingEntries.join("\n")}
-};
-`;
-}

package/src/generators/generate-client.ts

@@ -1,252 +0,0 @@
-import type { Model, Schema } from "@vibeorm/parser";
-import { fileHeader, toCamelCase } from "../utils.ts";
-
-/**
- * Generates the main index.ts file that:
- * - Re-exports all types
- * - Creates the VibeClient class that wires delegates to the runtime
- */
-export function generateClient(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Re-exports
-  parts.push(`export * from "./enums.ts";`);
-  parts.push(`export * from "./models.ts";`);
-  parts.push(`export * from "./inputs.ts";`);
-  parts.push(`export * from "./args.ts";`);
-  parts.push(`export * from "./result.ts";`);
-  parts.push(`export * from "./delegates.ts";`);
-  parts.push(`export * from "./schemas.ts";`);
-  parts.push(`export * from "./view-types.ts";`);
-  parts.push(``);
-
-  // Import delegate types
-  const delegateImports = schema.models
-    .map((m) => `${m.name}Delegate`)
-    .join(", ");
-  parts.push(`import type { ${delegateImports} } from "./delegates.ts";`);
-
-  // Import view types
-  parts.push(`import type { ViewDefinitionInput, ViewClient } from "./view-types.ts";`);
-
-  // Import runtime
-  parts.push(`import { createClient } from "@vibeorm/runtime";`);
-  parts.push(`import type { VibeClientOptions, TransactionOptions } from "@vibeorm/runtime";`);
-  parts.push(``);
-
-  // Import schemas for validation wiring
-  const schemaImports = schema.models.flatMap((m) => [
-    `${m.name}Schema`,
-    `${m.name}CreateInputSchema`,
-    `${m.name}UpdateInputSchema`,
-    `${m.name}WhereInputSchema`,
-  ]);
-  parts.push(`import { ${schemaImports.join(", ")} } from "./schemas.ts";`);
-  parts.push(``);
-
-  // Generate the model metadata object that the runtime needs
-  parts.push(generateModelMeta({ schema }));
-
-  // Generate the schemas map for validation wiring
-  parts.push(generateSchemasMap({ schema }));
-
-  // Generate the VibeClient type (intersection of all delegates)
-  const clientProperties = schema.models
-    .map((m) => generateClientProperty({ model: m }))
-    .join("\n");
-
-  parts.push(`export type VibeClientInstance = {
-${clientProperties}
-  $transaction<T>(fn: (tx: VibeClientInstance) => Promise<T>, options?: TransactionOptions): Promise<T>;
-  $transaction(promises: Promise<unknown>[], options?: TransactionOptions): Promise<unknown[]>;
-  $queryRaw<T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>;
-  $executeRaw(strings: TemplateStringsArray, ...values: unknown[]): Promise<number>;
-  $queryRawUnsafe<T = unknown>(query: string, ...values: unknown[]): Promise<T[]>;
-  $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
-  $connect(): Promise<void>;
-  $disconnect(): Promise<void>;
-
-  /**
-   * Create a read-only view that restricts which fields are returned per model.
-   *
-   * @example
-   * const publicApi = db.defineView({
-   *   name: "public-api",
-   *   definition: {
-   *     user: { id: true, name: true, createdAt: true },
-   *     post: { id: true, title: true },
-   *   },
-   * });
-   *
-   * // Only returns { id, name, createdAt }
-   * const users = await publicApi.user.findMany();
-   *
-   * // Reveal extra fields (accessible but excluded from JSON.stringify)
-   * const user = await publicApi.user.findUniqueOrThrow({
-   *   where: { id: 1 },
-   *   reveal: { email: true },
-   * });
-   * user.email;           // accessible
-   * JSON.stringify(user);  // { id, name, createdAt } — email excluded
-   * user.$unsafe();        // { id, name, createdAt, email } — escape hatch
-   */
-  defineView<D extends ViewDefinitionInput>(params: {
-    name: string;
-    definition: D;
-  }): ViewClient<D>;
-};
-`);
-
-  // Generate the VibeClient constructor function
-  parts.push(`export function VibeClient(options: VibeClientOptions): VibeClientInstance {
-  return createClient({
-    options,
-    modelMeta: MODEL_META,
-    schemas: options.validate ? SCHEMAS : undefined,
-  }) as unknown as VibeClientInstance;
-}
-`);
-
-  return parts.join("\n");
-}
-
-function generateClientProperty(params: { model: Model }): string {
-  const { model } = params;
-  const modelVar = toCamelCase({ str: model.name });
-
-  return `  /**
-   * Operations for the ${model.name} model.
-   *
-   * @example
-   * const rows = await db.${modelVar}.findMany();
-   *
-   * @example
-   * const filteredRows = await db.${modelVar}.findMany({
-   *   where: {
-   *     // Add ${model.name}-specific filters here
-   *   },
-   * });
-   *
-   * @example
-   * const page = await db.${modelVar}.findMany({
-   *   where: {
-   *     // Add ${model.name}-specific filters here
-   *   },
-   *   orderBy: {
-   *     // e.g. createdAt: "desc"
-   *   },
-   *   take: 20,
-   *   skip: 0,
-   * });
-   */
-  ${modelVar}: ${model.name}Delegate;`;
-}
-
-function generateModelMeta(params: { schema: Schema }): string {
-  const { schema } = params;
-
-  const modelEntries = schema.models.map((model) => {
-    const scalarFields = model.fields
-      .filter((f) => f.kind === "scalar" || f.kind === "enum")
-      .map((f) => {
-        const dbName = f.kind === "scalar" ? f.dbName : f.dbName;
-        const isUpdatedAt = f.kind === "scalar" && f.isUpdatedAt;
-        const extras: string[] = [];
-        if (isUpdatedAt) extras.push(`isUpdatedAt: true`);
-        if (f.kind === "scalar") extras.push(`type: "${f.prismaType}"`);
-        if (f.isList) extras.push(`isList: true`);
-
-        // Emit default kind for application-level generation (uuid, cuid, nanoid, ulid)
-        if (f.default) {
-          const appLevelDefaults = new Set(["uuid", "cuid", "nanoid", "ulid"]);
-          if (appLevelDefaults.has(f.default.kind)) {
-            extras.push(`hasDefault: "${f.default.kind}"`);
-          } else if (f.default.kind !== "dbgenerated") {
-            // autoincrement, now, literal — DB handles these, but runtime should know
-            extras.push(`hasDefault: true`);
-          }
-        }
-
-        // Extract @vibeorm.idPrefix from documentation comment
-        const doc = (f.kind === "scalar" || f.kind === "enum") ? f.documentation : undefined;
-        if (doc) {
-          const prefixMatch = doc.match(/@vibeorm\.idPrefix\(["']([^"']+)["']\)/);
-          if (prefixMatch) {
-            extras.push(`idPrefix: "${prefixMatch[1]}"`);
-          }
-        }
-
-        const extraStr = extras.length > 0 ? `, ${extras.join(", ")}` : "";
-        return `      { name: "${f.name}", dbName: "${dbName}", kind: "${f.kind}" as const${extraStr} }`;
-      });
-
-    const relationFields = model.fields
-      .filter((f) => f.kind === "relation")
-      .map((f) => {
-        if (f.kind !== "relation") return "";
-        const isM2M = f.relation.type === "manyToMany";
-        let joinTableLine = "";
-        if (isM2M) {
-          const sorted = [model.name, f.relatedModel].sort();
-          const jtName = `_${sorted[0]}To${sorted[1]}`;
-          joinTableLine = `\n        joinTable: "${jtName}",`;
-        }
-        const relationNameLine = f.relation.name
-          ? `\n        relationName: "${f.relation.name}",`
-          : "";
-        return `      {
-        name: "${f.name}",
-        kind: "relation" as const,
-        relatedModel: "${f.relatedModel}",
-        type: "${f.relation.type}" as const,
-        isList: ${f.isList},
-        isForeignKey: ${f.relation.isForeignKey},
-        fields: ${JSON.stringify(f.relation.fields)},
-        references: ${JSON.stringify(f.relation.references)},${relationNameLine}${joinTableLine}
-      }`;
-      });
-
-    const pkFields = JSON.stringify(model.primaryKey.fields);
-    const uniqueFields = model.fields
-      .filter((f) => (f.kind === "scalar" || f.kind === "enum") && f.isUnique)
-      .map((f) => `"${f.name}"`);
-
-    return `  ${toCamelCase({ str: model.name })}: {
-    name: "${model.name}",
-    dbName: "${model.dbName}",
-    primaryKey: ${pkFields},
-    uniqueFields: [${uniqueFields.join(", ")}],
-    scalarFields: [
-${scalarFields.join(",\n")}
-    ],
-    relationFields: [
-${relationFields.join(",\n")}
-    ],
-  }`;
-  });
-
-  return `const MODEL_META = {
-${modelEntries.join(",\n")}
-} as const;
-`;
-}
-
-function generateSchemasMap(params: { schema: Schema }): string {
-  const { schema } = params;
-
-  const entries = schema.models.map((model) => {
-    const key = toCamelCase({ str: model.name });
-    return `  ${key}: {
-    model: ${model.name}Schema,
-    createInput: ${model.name}CreateInputSchema,
-    updateInput: ${model.name}UpdateInputSchema,
-    whereInput: ${model.name}WhereInputSchema,
-  }`;
-  });
-
-  return `const SCHEMAS = {
-${entries.join(",\n")}
-};
-`;
-}