bopodev-db 0.1.14 → 0.1.16

package/src/repositories.ts

@@ -19,7 +19,11 @@ import {
   pluginConfigs,
   pluginRuns,
   plugins,
+  projectWorkspaces,
   projects,
+  templateInstalls,
+  templateVersions,
+  templates,
   touchUpdatedAtSql
 } from "./schema";
 
@@ -74,6 +78,17 @@ async function assertAgentBelongsToCompany(db: BopoDb, companyId: string, agentI
   }
 }
 
+async function assertTemplateBelongsToCompany(db: BopoDb, companyId: string, templateId: string) {
+  const [template] = await db
+    .select({ id: templates.id })
+    .from(templates)
+    .where(and(eq(templates.companyId, companyId), eq(templates.id, templateId)))
+    .limit(1);
+  if (!template) {
+    throw new RepositoryValidationError("Template not found for company.");
+  }
+}
+
 export async function createCompany(db: BopoDb, input: { name: string; mission?: string | null }) {
   const id = nanoid(12);
   await db.insert(companies).values({
@@ -106,7 +121,8 @@ export async function deleteCompany(db: BopoDb, id: string) {
 }
 
 export async function listProjects(db: BopoDb, companyId: string) {
-  return db.select().from(projects).where(eq(projects.companyId, companyId)).orderBy(desc(projects.createdAt));
+  const rows = await db.select().from(projects).where(eq(projects.companyId, companyId)).orderBy(desc(projects.createdAt));
+  return hydrateProjectsWithWorkspaces(db, rows);
 }
 
 export async function createProject(
@@ -118,6 +134,7 @@ export async function createProject(
     description?: string | null;
     status?: "planned" | "active" | "paused" | "blocked" | "completed" | "archived";
     plannedStartAt?: Date | null;
+    executionWorkspacePolicy?: Record<string, unknown> | null;
     workspaceLocalPath?: string | null;
     workspaceGithubRepo?: string | null;
   }
@@ -130,10 +147,21 @@ export async function createProject(
     description: input.description ?? null,
     status: input.status ?? "planned",
     plannedStartAt: input.plannedStartAt ?? null,
-    workspaceLocalPath: input.workspaceLocalPath ?? null,
-    workspaceGithubRepo: input.workspaceGithubRepo ?? null
+    executionWorkspacePolicy: input.executionWorkspacePolicy ? JSON.stringify(input.executionWorkspacePolicy) : null
   });
-  return { id, ...input };
+  const legacyWorkspaceLocalPath = input.workspaceLocalPath?.trim();
+  const legacyWorkspaceGithubRepo = input.workspaceGithubRepo?.trim();
+  if ((legacyWorkspaceLocalPath && legacyWorkspaceLocalPath.length > 0) || (legacyWorkspaceGithubRepo && legacyWorkspaceGithubRepo.length > 0)) {
+    await createProjectWorkspace(db, {
+      companyId: input.companyId,
+      projectId: id,
+      name: input.name,
+      cwd: legacyWorkspaceLocalPath && legacyWorkspaceLocalPath.length > 0 ? legacyWorkspaceLocalPath : null,
+      repoUrl: legacyWorkspaceGithubRepo && legacyWorkspaceGithubRepo.length > 0 ? legacyWorkspaceGithubRepo : null,
+      isPrimary: true
+    });
+  }
+  return getProjectById(db, input.companyId, id);
 }
 
 export async function updateProject(
@@ -145,6 +173,7 @@ export async function updateProject(
     description?: string | null;
     status?: "planned" | "active" | "paused" | "blocked" | "completed" | "archived";
     plannedStartAt?: Date | null;
+    executionWorkspacePolicy?: Record<string, unknown> | null;
     workspaceLocalPath?: string | null;
     workspaceGithubRepo?: string | null;
   }
@@ -157,13 +186,222 @@ export async function updateProject(
         description: input.description,
         status: input.status,
         plannedStartAt: input.plannedStartAt,
-        workspaceLocalPath: input.workspaceLocalPath,
-        workspaceGithubRepo: input.workspaceGithubRepo
+        executionWorkspacePolicy:
+          input.executionWorkspacePolicy === undefined
+            ? undefined
+            : input.executionWorkspacePolicy === null
+              ? null
+              : JSON.stringify(input.executionWorkspacePolicy),
+        updatedAt: touchUpdatedAtSql
       })
     )
     .where(and(eq(projects.companyId, input.companyId), eq(projects.id, input.id)))
     .returning();
-  return project ?? null;
+  if (!project) {
+    return null;
+  }
+  if (input.workspaceLocalPath !== undefined || input.workspaceGithubRepo !== undefined) {
+    const existingWorkspaces = await listProjectWorkspaces(db, input.companyId, input.id);
+    const primaryWorkspace = existingWorkspaces.find((workspace) => workspace.isPrimary) ?? existingWorkspaces[0] ?? null;
+    const hasAnyWorkspaceField =
+      (input.workspaceLocalPath?.trim() ?? "").length > 0 || (input.workspaceGithubRepo?.trim() ?? "").length > 0;
+    if (!hasAnyWorkspaceField) {
+      if (primaryWorkspace) {
+        await updateProjectWorkspace(db, {
+          companyId: input.companyId,
+          projectId: input.id,
+          id: primaryWorkspace.id,
+          cwd: null,
+          repoUrl: null
+        });
+      }
+    } else if (primaryWorkspace) {
+      await updateProjectWorkspace(db, {
+        companyId: input.companyId,
+        projectId: input.id,
+        id: primaryWorkspace.id,
+        cwd: input.workspaceLocalPath ?? null,
+        repoUrl: input.workspaceGithubRepo ?? null,
+        isPrimary: true
+      });
+    } else {
+      await createProjectWorkspace(db, {
+        companyId: input.companyId,
+        projectId: input.id,
+        name: input.name ?? project.name,
+        cwd: input.workspaceLocalPath ?? null,
+        repoUrl: input.workspaceGithubRepo ?? null,
+        isPrimary: true
+      });
+    }
+  }
+  return getProjectById(db, input.companyId, project.id);
+}
+
+export async function listProjectWorkspaces(db: BopoDb, companyId: string, projectId: string) {
+  return db
+    .select()
+    .from(projectWorkspaces)
+    .where(and(eq(projectWorkspaces.companyId, companyId), eq(projectWorkspaces.projectId, projectId)))
+    .orderBy(desc(projectWorkspaces.isPrimary), asc(projectWorkspaces.createdAt), asc(projectWorkspaces.id));
+}
+
+export async function createProjectWorkspace(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    projectId: string;
+    name: string;
+    cwd?: string | null;
+    repoUrl?: string | null;
+    repoRef?: string | null;
+    isPrimary?: boolean;
+  }
+) {
+  const id = nanoid(12);
+  return db.transaction(async (tx) => {
+    const existingWorkspaces = await tx
+      .select({ id: projectWorkspaces.id })
+      .from(projectWorkspaces)
+      .where(and(eq(projectWorkspaces.companyId, input.companyId), eq(projectWorkspaces.projectId, input.projectId)))
+      .limit(1);
+    const shouldBePrimary = input.isPrimary === true || existingWorkspaces.length === 0;
+    if (shouldBePrimary) {
+      await tx
+        .update(projectWorkspaces)
+        .set({ isPrimary: false, updatedAt: touchUpdatedAtSql })
+        .where(and(eq(projectWorkspaces.companyId, input.companyId), eq(projectWorkspaces.projectId, input.projectId)));
+    }
+    const [workspace] = await tx
+      .insert(projectWorkspaces)
+      .values({
+        id,
+        companyId: input.companyId,
+        projectId: input.projectId,
+        name: input.name,
+        cwd: input.cwd ?? null,
+        repoUrl: input.repoUrl ?? null,
+        repoRef: input.repoRef ?? null,
+        isPrimary: shouldBePrimary
+      })
+      .returning();
+    return workspace;
+  });
+}
+
+export async function updateProjectWorkspace(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    projectId: string;
+    id: string;
+    name?: string;
+    cwd?: string | null;
+    repoUrl?: string | null;
+    repoRef?: string | null;
+    isPrimary?: boolean;
+  }
+) {
+  return db.transaction(async (tx) => {
+    if (input.isPrimary === true) {
+      await tx
+        .update(projectWorkspaces)
+        .set({ isPrimary: false, updatedAt: touchUpdatedAtSql })
+        .where(and(eq(projectWorkspaces.companyId, input.companyId), eq(projectWorkspaces.projectId, input.projectId)));
+    }
+
+    const [workspace] = await tx
+      .update(projectWorkspaces)
+      .set(
+        compactUpdate({
+          name: input.name,
+          cwd: input.cwd,
+          repoUrl: input.repoUrl,
+          repoRef: input.repoRef,
+          isPrimary: input.isPrimary,
+          updatedAt: touchUpdatedAtSql
+        })
+      )
+      .where(
+        and(
+          eq(projectWorkspaces.companyId, input.companyId),
+          eq(projectWorkspaces.projectId, input.projectId),
+          eq(projectWorkspaces.id, input.id)
+        )
+      )
+      .returning();
+
+    if (!workspace) {
+      return null;
+    }
+
+    const primary = await tx
+      .select({ id: projectWorkspaces.id })
+      .from(projectWorkspaces)
+      .where(
+        and(
+          eq(projectWorkspaces.companyId, input.companyId),
+          eq(projectWorkspaces.projectId, input.projectId),
+          eq(projectWorkspaces.isPrimary, true)
+        )
+      )
+      .limit(1);
+    if (primary.length === 0) {
+      await tx
+        .update(projectWorkspaces)
+        .set({ isPrimary: true, updatedAt: touchUpdatedAtSql })
+        .where(
+          and(
+            eq(projectWorkspaces.companyId, input.companyId),
+            eq(projectWorkspaces.projectId, input.projectId),
+            eq(projectWorkspaces.id, workspace.id)
+          )
+        );
+      const [rehydrated] = await tx
+        .select()
+        .from(projectWorkspaces)
+        .where(eq(projectWorkspaces.id, workspace.id))
+        .limit(1);
+      return rehydrated ?? workspace;
+    }
+    return workspace;
+  });
+}
+
+export async function deleteProjectWorkspace(
+  db: BopoDb,
+  input: { companyId: string; projectId: string; id: string }
+) {
+  return db.transaction(async (tx) => {
+    const [workspace] = await tx
+      .delete(projectWorkspaces)
+      .where(
+        and(
+          eq(projectWorkspaces.companyId, input.companyId),
+          eq(projectWorkspaces.projectId, input.projectId),
+          eq(projectWorkspaces.id, input.id)
+        )
+      )
+      .returning();
+    if (!workspace) {
+      return null;
+    }
+    if (workspace.isPrimary) {
+      const [fallback] = await tx
+        .select({ id: projectWorkspaces.id })
+        .from(projectWorkspaces)
+        .where(and(eq(projectWorkspaces.companyId, input.companyId), eq(projectWorkspaces.projectId, input.projectId)))
+        .orderBy(asc(projectWorkspaces.createdAt), asc(projectWorkspaces.id))
+        .limit(1);
+      if (fallback) {
+        await tx
+          .update(projectWorkspaces)
+          .set({ isPrimary: true, updatedAt: touchUpdatedAtSql })
+          .where(eq(projectWorkspaces.id, fallback.id));
+      }
+    }
+    return workspace;
+  });
 }
 
 export async function syncProjectGoals(
@@ -213,6 +451,67 @@ export async function deleteProject(db: BopoDb, companyId: string, id: string) {
   return Boolean(deletedProject);
 }
 
+async function getProjectById(db: BopoDb, companyId: string, projectId: string) {
+  const [row] = await db
+    .select()
+    .from(projects)
+    .where(and(eq(projects.companyId, companyId), eq(projects.id, projectId)))
+    .limit(1);
+  if (!row) {
+    return null;
+  }
+  const [project] = await hydrateProjectsWithWorkspaces(db, [row]);
+  return project ?? null;
+}
+
+async function hydrateProjectsWithWorkspaces(
+  db: BopoDb,
+  projectRows: Array<typeof projects.$inferSelect>
+) {
+  if (projectRows.length === 0) {
+    return [] as Array<
+      typeof projects.$inferSelect & {
+        executionWorkspacePolicy: Record<string, unknown> | null;
+        workspaces: Array<typeof projectWorkspaces.$inferSelect>;
+        primaryWorkspace: typeof projectWorkspaces.$inferSelect | null;
+      }
+    >;
+  }
+  const projectIds = projectRows.map((project) => project.id);
+  const workspaces = await db
+    .select()
+    .from(projectWorkspaces)
+    .where(inArray(projectWorkspaces.projectId, projectIds))
+    .orderBy(desc(projectWorkspaces.isPrimary), asc(projectWorkspaces.createdAt), asc(projectWorkspaces.id));
+  const workspacesByProject = new Map<string, Array<typeof projectWorkspaces.$inferSelect>>();
+  for (const workspace of workspaces) {
+    const existing = workspacesByProject.get(workspace.projectId) ?? [];
+    existing.push(workspace);
+    workspacesByProject.set(workspace.projectId, existing);
+  }
+
+  return projectRows.map((project) => {
+    const projectWorkspacesRows = workspacesByProject.get(project.id) ?? [];
+    const primaryWorkspace = projectWorkspacesRows.find((workspace) => workspace.isPrimary) ?? projectWorkspacesRows[0] ?? null;
+    let executionWorkspacePolicy: Record<string, unknown> | null = null;
+    if (project.executionWorkspacePolicy) {
+      try {
+        executionWorkspacePolicy = JSON.parse(project.executionWorkspacePolicy) as Record<string, unknown>;
+      } catch {
+        executionWorkspacePolicy = null;
+      }
+    }
+    return {
+      ...project,
+      workspaceLocalPath: primaryWorkspace?.cwd ?? null,
+      workspaceGithubRepo: primaryWorkspace?.repoUrl ?? null,
+      executionWorkspacePolicy,
+      workspaces: projectWorkspacesRows,
+      primaryWorkspace
+    };
+  });
+}
+
 export async function listIssues(db: BopoDb, companyId: string, projectId?: string) {
   const where = projectId
     ? and(eq(issues.companyId, companyId), eq(issues.projectId, projectId))
@@ -754,6 +1053,14 @@ export async function listApprovalRequests(db: BopoDb, companyId: string) {
     .orderBy(desc(approvalRequests.createdAt));
 }
 
+export async function countPendingApprovalRequests(db: BopoDb, companyId: string) {
+  const [row] = await db
+    .select({ count: sql<number>`count(*)` })
+    .from(approvalRequests)
+    .where(and(eq(approvalRequests.companyId, companyId), eq(approvalRequests.status, "pending")));
+  return Number(row?.count ?? 0);
+}
+
 export async function listApprovalInboxStates(db: BopoDb, companyId: string, actorId: string) {
   return db
     .select()
@@ -1258,6 +1565,215 @@ export async function listPluginRuns(
     .limit(limit);
 }
 
+export async function listTemplates(db: BopoDb, companyId: string) {
+  return db
+    .select()
+    .from(templates)
+    .where(eq(templates.companyId, companyId))
+    .orderBy(desc(templates.updatedAt), asc(templates.slug));
+}
+
+export async function getTemplate(db: BopoDb, companyId: string, templateId: string) {
+  const [template] = await db
+    .select()
+    .from(templates)
+    .where(and(eq(templates.companyId, companyId), eq(templates.id, templateId)))
+    .limit(1);
+  return template ?? null;
+}
+
+export async function getTemplateBySlug(db: BopoDb, companyId: string, slug: string) {
+  const [template] = await db
+    .select()
+    .from(templates)
+    .where(and(eq(templates.companyId, companyId), eq(templates.slug, slug)))
+    .limit(1);
+  return template ?? null;
+}
+
+export async function createTemplate(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    slug: string;
+    name: string;
+    description?: string | null;
+    currentVersion?: string;
+    status?: "draft" | "published" | "archived";
+    visibility?: "company" | "private";
+    variablesJson?: string;
+  }
+) {
+  const id = nanoid(12);
+  const [template] = await db
+    .insert(templates)
+    .values({
+      id,
+      companyId: input.companyId,
+      slug: input.slug,
+      name: input.name,
+      description: input.description ?? null,
+      currentVersion: input.currentVersion ?? "1.0.0",
+      status: input.status ?? "draft",
+      visibility: input.visibility ?? "company",
+      variablesJson: input.variablesJson ?? "[]"
+    })
+    .returning();
+  return template ?? null;
+}
+
+export async function updateTemplate(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    id: string;
+    slug?: string;
+    name?: string;
+    description?: string | null;
+    currentVersion?: string;
+    status?: "draft" | "published" | "archived";
+    visibility?: "company" | "private";
+    variablesJson?: string;
+  }
+) {
+  const [template] = await db
+    .update(templates)
+    .set(
+      compactUpdate({
+        slug: input.slug,
+        name: input.name,
+        description: input.description,
+        currentVersion: input.currentVersion,
+        status: input.status,
+        visibility: input.visibility,
+        variablesJson: input.variablesJson,
+        updatedAt: touchUpdatedAtSql
+      })
+    )
+    .where(and(eq(templates.companyId, input.companyId), eq(templates.id, input.id)))
+    .returning();
+  return template ?? null;
+}
+
+export async function deleteTemplate(db: BopoDb, companyId: string, templateId: string) {
+  const [deleted] = await db
+    .delete(templates)
+    .where(and(eq(templates.companyId, companyId), eq(templates.id, templateId)))
+    .returning({ id: templates.id });
+  return Boolean(deleted);
+}
+
+export async function listTemplateVersions(db: BopoDb, companyId: string, templateId: string) {
+  await assertTemplateBelongsToCompany(db, companyId, templateId);
+  return db
+    .select()
+    .from(templateVersions)
+    .where(and(eq(templateVersions.companyId, companyId), eq(templateVersions.templateId, templateId)))
+    .orderBy(desc(templateVersions.createdAt));
+}
+
+export async function getTemplateVersionByVersion(
+  db: BopoDb,
+  input: { companyId: string; templateId: string; version: string }
+) {
+  const [row] = await db
+    .select()
+    .from(templateVersions)
+    .where(
+      and(
+        eq(templateVersions.companyId, input.companyId),
+        eq(templateVersions.templateId, input.templateId),
+        eq(templateVersions.version, input.version)
+      )
+    )
+    .limit(1);
+  return row ?? null;
+}
+
+export async function getCurrentTemplateVersion(db: BopoDb, companyId: string, templateId: string) {
+  const template = await getTemplate(db, companyId, templateId);
+  if (!template) {
+    return null;
+  }
+  return getTemplateVersionByVersion(db, {
+    companyId,
+    templateId,
+    version: template.currentVersion
+  });
+}
+
+export async function createTemplateVersion(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    templateId: string;
+    version: string;
+    manifestJson: string;
+  }
+) {
+  await assertTemplateBelongsToCompany(db, input.companyId, input.templateId);
+  const id = nanoid(14);
+  const [row] = await db
+    .insert(templateVersions)
+    .values({
+      id,
+      companyId: input.companyId,
+      templateId: input.templateId,
+      version: input.version,
+      manifestJson: input.manifestJson
+    })
+    .returning();
+  return row ?? null;
+}
+
+export async function listTemplateInstalls(
+  db: BopoDb,
+  input: { companyId: string; templateId?: string; limit?: number }
+) {
+  const limit = Math.min(Math.max(input.limit ?? 200, 1), 1000);
+  return db
+    .select()
+    .from(templateInstalls)
+    .where(
+      and(
+        eq(templateInstalls.companyId, input.companyId),
+        input.templateId ? eq(templateInstalls.templateId, input.templateId) : undefined
+      )
+    )
+    .orderBy(desc(templateInstalls.createdAt))
+    .limit(limit);
+}
+
+export async function createTemplateInstall(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    templateId?: string | null;
+    templateVersionId?: string | null;
+    status?: "applied" | "queued" | "failed";
+    summaryJson?: string;
+    variablesJson?: string;
+  }
+) {
+  if (input.templateId) {
+    await assertTemplateBelongsToCompany(db, input.companyId, input.templateId);
+  }
+  const id = nanoid(14);
+  const [row] = await db
+    .insert(templateInstalls)
+    .values({
+      id,
+      companyId: input.companyId,
+      templateId: input.templateId ?? null,
+      templateVersionId: input.templateVersionId ?? null,
+      status: input.status ?? "applied",
+      summaryJson: input.summaryJson ?? "{}",
+      variablesJson: input.variablesJson ?? "{}"
+    })
+    .returning();
+  return row ?? null;
+}
+
 export async function listModelPricing(db: BopoDb, companyId: string) {
   return db
     .select()

package/src/schema.ts

@@ -17,9 +17,26 @@ export const projects = pgTable("projects", {
   description: text("description"),
   status: text("status").notNull().default("planned"),
   plannedStartAt: timestamp("planned_start_at", { mode: "date" }),
-  workspaceLocalPath: text("workspace_local_path"),
-  workspaceGithubRepo: text("workspace_github_repo"),
-  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull()
+  executionWorkspacePolicy: text("execution_workspace_policy"),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).defaultNow().notNull()
+});
+
+export const projectWorkspaces = pgTable("project_workspaces", {
+  id: text("id").primaryKey(),
+  companyId: text("company_id")
+    .notNull()
+    .references(() => companies.id, { onDelete: "cascade" }),
+  projectId: text("project_id")
+    .notNull()
+    .references(() => projects.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  cwd: text("cwd"),
+  repoUrl: text("repo_url"),
+  repoRef: text("repo_ref"),
+  isPrimary: boolean("is_primary").notNull().default(false),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).defaultNow().notNull()
 });
 
 export const goals = pgTable("goals", {
@@ -253,6 +270,48 @@ export const plugins = pgTable("plugins", {
   updatedAt: timestamp("updated_at", { mode: "date" }).defaultNow().notNull()
 });
 
+export const templates = pgTable("templates", {
+  id: text("id").primaryKey(),
+  companyId: text("company_id")
+    .notNull()
+    .references(() => companies.id, { onDelete: "cascade" }),
+  slug: text("slug").notNull(),
+  name: text("name").notNull(),
+  description: text("description"),
+  currentVersion: text("current_version").notNull().default("1.0.0"),
+  status: text("status").notNull().default("draft"),
+  visibility: text("visibility").notNull().default("company"),
+  variablesJson: text("variables_json").notNull().default("[]"),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { mode: "date" }).defaultNow().notNull()
+});
+
+export const templateVersions = pgTable("template_versions", {
+  id: text("id").primaryKey(),
+  companyId: text("company_id")
+    .notNull()
+    .references(() => companies.id, { onDelete: "cascade" }),
+  templateId: text("template_id")
+    .notNull()
+    .references(() => templates.id, { onDelete: "cascade" }),
+  version: text("version").notNull(),
+  manifestJson: text("manifest_json").notNull().default("{}"),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull()
+});
+
+export const templateInstalls = pgTable("template_installs", {
+  id: text("id").primaryKey(),
+  companyId: text("company_id")
+    .notNull()
+    .references(() => companies.id, { onDelete: "cascade" }),
+  templateId: text("template_id").references(() => templates.id, { onDelete: "set null" }),
+  templateVersionId: text("template_version_id").references(() => templateVersions.id, { onDelete: "set null" }),
+  status: text("status").notNull().default("applied"),
+  summaryJson: text("summary_json").notNull().default("{}"),
+  variablesJson: text("variables_json").notNull().default("{}"),
+  createdAt: timestamp("created_at", { mode: "date" }).defaultNow().notNull()
+});
+
 export const modelPricing = pgTable(
   "model_pricing",
   {
@@ -339,8 +398,12 @@ export const schema = {
   plugins,
   pluginConfigs,
   pluginRuns,
+  templates,
+  templateVersions,
+  templateInstalls,
   modelPricing,
-  agentIssueLabels
+  agentIssueLabels,
+  projectWorkspaces
 };
 
 export const touchUpdatedAtSql = sql`CURRENT_TIMESTAMP`;