@vibeorm/generator 1.3.0 → 2.0.0-alpha.1

package/src/generators/generate-models.ts

@@ -1,130 +0,0 @@
-import type { Model, Schema, Field, ScalarField, EnumField, RelationField } from "@vibeorm/parser";
-import { fileHeader, toCamelCase } from "../utils.ts";
-
-/**
- * Generates the Payload types for each model.
- * These split each model into { scalars, objects, composites }
- * which is the foundation for select/include type narrowing.
- */
-export function generateModels(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Import enums if any
-  if (schema.enums.length > 0) {
-    const enumImports = schema.enums.map((e) => e.name).join(", ");
-    parts.push(`import type { ${enumImports} } from "./enums.ts";\n`);
-  }
-
-  // Generate JsonValue type.
-  //
-  // Arrays and object index signatures are `readonly` so that `readonly T[]` /
-  // `ReadonlyArray<T>` (common in typed catalogues, factories, seed scripts) can
-  // be assigned into Json columns without forcing a spread/cast at every call
-  // site. Postgres doesn't care about JS array mutability — this is a purely
-  // type-level relaxation that's strictly more permissive in argument position.
-  parts.push(`export type JsonValue = string | number | boolean | null | readonly JsonValue[] | { readonly [key: string]: JsonValue };\n`);
-
-  // InputJsonValue — looser than JsonValue, used in CreateInput/UpdateInput
-  // for Json fields (Bug 8). Accepts:
-  //   - all JsonValue shapes (readonly arrays / readonly object index sigs)
-  //   - any object exposing toJSON() (Date, Decimal wrappers, BigInt wrappers, …)
-  //
-  // The `toJSON` escape hatch is what lets users feed seed/factory data typed
-  // as `Record<string, unknown>` via a single intentional cast, instead of
-  // rewriting every call site. Postgres jsonb doesn't care about the JS shape —
-  // the adapter JSON.stringifies whatever it gets. Output types keep the strict
-  // `JsonValue`.
-  parts.push(`export type InputJsonObject = { readonly [key: string]: InputJsonValue | null | undefined };
-export type InputJsonArray = ReadonlyArray<InputJsonValue | null>;
-export type InputJsonValue =
-  | string
-  | number
-  | boolean
-  | InputJsonObject
-  | InputJsonArray
-  | { toJSON(): unknown };
-`);
-
-  // Generate the base OperationPayload interface
-  parts.push(`export type OperationPayload = {
-  name: string;
-  scalars: Record<string, unknown>;
-  objects: Record<string, unknown>;
-  composites: Record<string, unknown>;
-};\n`);
-
-  // Generate payload type for each model
-  for (const model of schema.models) {
-    parts.push(generatePayloadType({ model, schema }));
-  }
-
-  // Generate plain model types (default selection = scalars only)
-  for (const model of schema.models) {
-    parts.push(generatePlainModelType({ model, schema }));
-  }
-
-  return parts.join("\n");
-}
-
-function generatePayloadType(params: { model: Model; schema: Schema }): string {
-  const { model, schema } = params;
-
-  const scalarFields = model.fields.filter(
-    (f): f is ScalarField | EnumField => f.kind === "scalar" || f.kind === "enum"
-  );
-  const relationFields = model.fields.filter(
-    (f): f is RelationField => f.kind === "relation"
-  );
-
-  // Scalars block
-  const scalarsEntries = scalarFields.map((f) => {
-    const tsType = f.kind === "scalar" ? f.tsType : f.enumName;
-    const nullable = f.isRequired ? "" : " | null";
-    const listPrefix = f.isList ? "" : "";
-    const listSuffix = f.isList ? "[]" : "";
-    return `    ${f.name}: ${listPrefix}${tsType}${nullable}${listSuffix};`;
-  });
-
-  // Objects block
-  const objectsEntries = relationFields.map((f) => {
-    const payloadType = `$${f.relatedModel}Payload`;
-    if (f.isList) {
-      return `    ${f.name}: ${payloadType}[];`;
-    }
-    const nullable = f.isRequired ? "" : " | null";
-    return `    ${f.name}: ${payloadType}${nullable};`;
-  });
-
-  return `export type $${model.name}Payload = {
-  name: "${model.name}";
-  scalars: {
-${scalarsEntries.join("\n")}
-  };
-  objects: {
-${objectsEntries.join("\n")}
-  };
-  composites: {};
-};
-`;
-}
-
-function generatePlainModelType(params: { model: Model; schema: Schema }): string {
-  const { model } = params;
-
-  const scalarFields = model.fields.filter(
-    (f): f is ScalarField | EnumField => f.kind === "scalar" || f.kind === "enum"
-  );
-
-  const entries = scalarFields.map((f) => {
-    const tsType = f.kind === "scalar" ? f.tsType : f.enumName;
-    const nullable = f.isRequired ? "" : " | null";
-    const listSuffix = f.isList ? "[]" : "";
-    return `  ${f.name}: ${tsType}${nullable}${listSuffix};`;
-  });
-
-  return `export type ${model.name} = {
-${entries.join("\n")}
-};
-`;
-}

package/src/generators/generate-result.ts

@@ -1,182 +0,0 @@
-import { fileHeader } from "../utils.ts";
-import type { Schema } from "@vibeorm/parser";
-
-/**
- * Generates the core type resolution engine.
- *
- * This produces the conditional types that narrow return types
- * based on the select/include args passed to operations.
- *
- * The pattern:
- * - No select/include → DefaultSelection (scalars only)
- * - select: { field: true } → only selected fields
- * - include: { relation: true } → scalars + included relations
- * - Nested select/include in relations → recursive narrowing
- */
-export function generateResult(params: { schema: Schema }): string {
-  const { schema } = params;
-  const parts: string[] = [fileHeader()];
-
-  // Import payload types
-  const payloadImports = schema.models
-    .map((m) => `$${m.name}Payload`)
-    .join(", ");
-  parts.push(
-    `import type { ${payloadImports}, OperationPayload } from "./models.ts";\n`
-  );
-
-  // ─── Utility Types ────────────────────────────────────────────────
-
-  parts.push(`
-// ─── Core Utility Types ───────────────────────────────────────────
-
-/** Detect if T is exactly \`any\` */
-type IsAny<T> = 0 extends 1 & T ? true : false;
-
-/** Flatten intersection types for cleaner hover tooltips */
-type Compute<T> = T extends Function ? T : { [K in keyof T]: T[K] } & unknown;
-
-/**
- * Enforces strict type safety by recursively rejecting excess properties.
- *
- * TypeScript's structural subtyping allows objects to have extra properties
- * when passed through generics (\`<T extends Args>\`). This utility type
- * maps any key in A that is NOT in W to \`never\`, causing a compile-time
- * error when unknown keys (e.g. typos in where/select/include) are used.
- *
- * Primitives, arrays, functions, and Dates are passed through unchanged
- * to preserve literal types for return type narrowing via GetFindResult.
- */
-export type Exact<A, W> = W extends unknown
-  ? A extends W
-    ? A extends Record<string, unknown>
-      ? { [K in keyof A]: K extends keyof W ? Exact<A[K], W[K]> : never }
-      : A
-    : W
-  : never;
-
-/** Extract scalar fields from a payload (default selection) */
-type DefaultSelection<P extends OperationPayload> = P["scalars"];
-
-/**
- * Check if a key exists in the payload's objects or composites
- * and extract the value type.
- */
-type SelectableObject<P extends OperationPayload, K extends PropertyKey> =
-  K extends keyof P["objects"] ? P["objects"][K] : never;
-
-// ─── GetFindResult ────────────────────────────────────────────────
-
-/**
- * The core type that resolves the result type based on select/include args.
- *
- * - If no args or args is any → DefaultSelection (scalars only)
- * - If select is provided → only selected fields (scalars + expanded relations)
- * - If include is provided → all scalars + included relations
- */
-export type GetFindResult<P extends OperationPayload, A> =
-  // If Args is any (no args passed), return default
-  IsAny<A> extends true
-    ? DefaultSelection<P>
-    : A extends { select: infer S extends Record<string, unknown> }
-      ? // ── SELECT branch ──
-        Compute<{
-          [K in keyof S as S[K] extends false | undefined | null
-            ? never
-            : K]: K extends keyof P["scalars"]
-            ? // Scalar field selected
-              P["scalars"][K]
-            : K extends keyof P["objects"]
-              ? // Relation field selected
-                P["objects"][K] extends OperationPayload[]
-                ? // Array relation
-                  S[K] extends Record<string, unknown>
-                  ? GetFindResult<P["objects"][K][number], S[K]>[]
-                  : DefaultSelection<P["objects"][K][number]>[]
-                : P["objects"][K] extends OperationPayload
-                  ? // Required single relation (checked before nullable to avoid false match)
-                    S[K] extends Record<string, unknown>
-                    ? GetFindResult<P["objects"][K], S[K]>
-                    : DefaultSelection<P["objects"][K]>
-                  : P["objects"][K] extends OperationPayload | null
-                    ? // Nullable single relation
-                      S[K] extends Record<string, unknown>
-                      ? GetFindResult<NonNullable<P["objects"][K]> & OperationPayload, S[K]> | null
-                      : DefaultSelection<NonNullable<P["objects"][K]> & OperationPayload> | null
-                    : never
-              : never;
-        }>
-      : A extends { include: infer I extends Record<string, unknown> }
-        ? // ── INCLUDE branch ──
-          // All scalars + included relations
-          Compute<
-            DefaultSelection<P> & {
-              [K in keyof I as I[K] extends false | undefined | null
-                ? never
-                : K]: K extends keyof P["objects"]
-                ? P["objects"][K] extends OperationPayload[]
-                  ? // Array relation
-                    I[K] extends Record<string, unknown>
-                    ? GetFindResult<P["objects"][K][number], I[K]>[]
-                    : DefaultSelection<P["objects"][K][number]>[]
-                  : P["objects"][K] extends OperationPayload
-                    ? // Required single relation (checked before nullable to avoid false match)
-                      I[K] extends Record<string, unknown>
-                      ? GetFindResult<P["objects"][K], I[K]>
-                      : DefaultSelection<P["objects"][K]>
-                    : P["objects"][K] extends OperationPayload | null
-                      ? // Nullable single relation
-                        I[K] extends Record<string, unknown>
-                        ? GetFindResult<NonNullable<P["objects"][K]> & OperationPayload, I[K]> | null
-                        : DefaultSelection<NonNullable<P["objects"][K]> & OperationPayload> | null
-                      : never
-                : never;
-            }
-          >
-        : // ── No select/include ──
-          DefaultSelection<P>;
-
-// ─── Operation Result Types ───────────────────────────────────────
-
-/**
- * Maps an operation name to the correct result cardinality.
- */
-export type GetResult<
-  P extends OperationPayload,
-  A,
-  Op extends string,
-> = {
-  findMany: GetFindResult<P, A>[];
-  findFirst: GetFindResult<P, A> | null;
-  findUnique: GetFindResult<P, A> | null;
-  findUniqueOrThrow: GetFindResult<P, A>;
-  findFirstOrThrow: GetFindResult<P, A>;
-  create: GetFindResult<P, A>;
-  createMany: { count: number };
-  createManyAndReturn: GetFindResult<P, A>[];
-  update: GetFindResult<P, A>;
-  upsert: GetFindResult<P, A>;
-  delete: GetFindResult<P, A>;
-  count: number;
-  deleteMany: { count: number };
-  updateMany: { count: number };
-}[Op & keyof {
-  findMany: unknown;
-  findFirst: unknown;
-  findUnique: unknown;
-  findUniqueOrThrow: unknown;
-  findFirstOrThrow: unknown;
-  create: unknown;
-  createMany: unknown;
-  createManyAndReturn: unknown;
-  update: unknown;
-  upsert: unknown;
-  delete: unknown;
-  count: unknown;
-  deleteMany: unknown;
-  updateMany: unknown;
-}];
-`);
-
-  return parts.join("\n");
-}