import { defineConfig, typesPlugin, zodPlugin } from "@danielfgray/pg-sourcerer"

export default defineConfig({
  connectionString: process.env.DATABASE_URL,
  schemas: ["public"],
  outputDir: "./src/generated",
  plugins: [
    typesPlugin({ outputDir: "types" }),
    zodPlugin({ outputDir: "schemas" }),
  ],
})

import type { UserRole } from "./UserRole.js";

export interface User {
  id: string;
  username: string;
  name?: string | null;
  role: UserRole;
  bio: string;
  isVerified: boolean;
  createdAt: Date;
  updatedAt: Date;
}

export interface UserUpdate {
  username?: string;
  name?: string | null;
  bio?: string;
}

import { z } from "zod";

export const User = z.object({
  id: z.string().uuid(),
  username: z.string(),
  name: z.string().nullable().optional(),
  role: z.enum(["admin", "moderator", "user"]),
  bio: z.string(),
  isVerified: z.boolean(),
  createdAt: z.coerce.date(),
  updatedAt: z.coerce.date(),
});

export type User = z.infer<typeof User>;

import { type } from "arktype";

export const User = type({
  id: "string.uuid",
  username: "string",
  "name?": "string | null",
  role: "'admin' | 'moderator' | 'user'",
  bio: "string",
  isVerified: "boolean",
  createdAt: "Date",
  updatedAt: "Date",
});

export type User = typeof User.infer;

import { Model } from "@effect/sql";
import { Schema as S } from "effect";

export class User extends Model.Class<User>("User")({
  id: Model.Generated(S.UUID),
  username: S.String,
  name: S.NullOr(S.String),
  role: S.Union(S.Literal("admin"), S.Literal("moderator"), S.Literal("user")),
  bio: S.String,
  isVerified: S.Boolean,
  createdAt: Model.DateTimeInsertFromDate,
  updatedAt: Model.DateTimeUpdateFromDate,
}) {}

import { sql } from "./sql-tag.js";
import type { User, UserInsert, UserUpdate } from "../types/User.js";

export async function findUserById({ id }: Pick<User, "id">) {
  const [result] = await sql<User[]>`select * from app_public.users where id = ${id}`;
  return result;
}

export async function findManyUsers({ limit = 50, offset = 0 }: { limit?: number; offset?: number; }) {
  return await sql<User[]>`select * from app_public.users limit ${limit} offset ${offset}`;
}

export async function getUserByUsername({ username }: Pick<User, "username">) {
  const [result] = await sql<User[]>`select * from app_public.users where username = ${username}`;
  return result;
}

export async function getUsersByUsername({ username }: Pick<User, "username">) {
  return await sql<User[]>`select * from app_public.users where username = ${username}`;
}

import type { Kysely, Updateable } from "kysely";
import type { DB, AppPublicUsers } from "../DB.js";

export const users = {
  findById: (db: Kysely<DB>, id: string) => db
    .selectFrom("app_public.users")
    .selectAll()
    .where("id", "=", id)
    .executeTakeFirst(),
  update: (db: Kysely<DB>, id: string, data: Updateable<AppPublicUsers>) => db
    .updateTable("app_public.users")
    .set(data)
    .where("id", "=", id)
    .returningAll()
    .executeTakeFirstOrThrow(),
  findOneByUsername: (db: Kysely<DB>, username: string) => db
    .selectFrom("app_public.users")
    .selectAll()
    .where("username", "=", username)
    .executeTakeFirst()
};

defineConfig({
  // ...
  typeHints: [
    {
      match: { pgType: "uuid" },
      hints: { ts: "string", zod: "z.string().uuid()" }
    },
    {
      match: { table: "users", column: "email" },
      hints: { ts: "Email", zod: "emailSchema", import: { Email: "./branded.js" } }
    },
  ],
})

import { definePlugin, conjure, Schema as S } from "@danielfgray/pg-sourcerer"

const { ts, exp } = conjure

export const myPlugin = definePlugin({
  name: "my-plugin",
  provides: ["my-types"],
  configSchema: S.Struct({
    outputDir: S.String,
  }),
  inflection: {
    outputFile: (ctx) => `${ctx.entityName}.ts`,
    symbolName: (entity, kind) => `${entity}${kind}`,
  },

  run: (ctx, config) => {
    ctx.ir.entities.forEach((entity, name) => {
      // Build interface properties from row shape
      const props = entity.shapes.row.fields.map((field) => ({
        name: field.name,
        type: field.nullable 
          ? ts.union(ts.string(), ts.null()) 
          : ts.string(),
        optional: field.optional,
      }))

      // Create exported interface with symbol tracking
      const statement = exp.interface(
        `${name}Row`,
        { capability: "my-types", entity: name, shape: "row" },
        props
      )

      // Emit file
      ctx.file(`${config.outputDir}/${name}.ts`)
        .header("// Auto-generated\n")
        .ast(conjure.symbolProgram(statement))
        .emit()
    })
  },
})

// Method chains: z.string().uuid()
conjure.id("z").method("string").method("uuid").build()

// Object literals: { path: "/users", method: "GET" }
conjure.obj()
  .prop("path", conjure.str("/users"))
  .prop("method", conjure.str("GET"))
  .build()

// TypeScript types
conjure.ts.string()                              // string
conjure.ts.ref("User")                           // User
conjure.ts.array(conjure.ts.string())            // string[]
conjure.ts.union(conjure.ts.string(), ts.null()) // string | null

// Statements
conjure.stmt.const("x", conjure.num(42))         // const x = 42
conjure.stmt.return(conjure.id("result"))        // return result

// Exports with symbol tracking (for import resolution)
exp.interface("UserRow", symbolCtx, properties)
exp.const("UserSchema", symbolCtx, schemaExpr)
exp.typeAlias("UserId", symbolCtx, ts.string())

// Print to code string
conjure.print(node)

definePlugin({
  name: "zod-schemas",
  requires: ["types"],  // Must run after types plugin
  provides: ["schemas:zod"],
  // ...
})

run: (ctx) => {
  const typesArtifact = ctx.getArtifact("types")
  // Use data from types plugin
}