Reorganize repo structure and standards references

This commit is contained in:
david committed 2026-06-29 05:03:42 +02:00
1 parent 3cb93a81be
commit be2054274d
5885 files changed
+2588 -195

No files matched your search

@@ -0,0 +1,163 @@
import { ActionFunction, LoaderFunctionArgs, redirect } from "react-router";
import type { TFunction } from "i18next";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import NotificationService from "~/modules/notifications/services/.server/NotificationService";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { EntityWithDetails, getAllEntities } from "~/utils/db/entities/entities.db.server";
import { getUser } from "~/utils/db/users.db.server";
import EntityHelper from "~/utils/helpers/EntityHelper";
import { verifyUserHasEntityPermission } from "~/utils/helpers/.server/PermissionsService";
import RowHelper from "~/utils/helpers/RowHelper";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import FormulaService from "~/modules/formulas/services/.server/FormulaService";
import { safeRedirectPathFromRequest } from "~/utils/app/RedirectSafety.server";
import { createScopedLogger } from "~/utils/logger.server";
import i18next from "i18next";
import { translateEntityTitlePlural } from "~/utils/i18n/translateLabel";
import { getRowsRouteErrorCode, getRowsRouteErrorStatus, translateRowsRouteError } from "./Rows_Error.server";
const rowsEditLogger = createScopedLogger("rows.edit");
export namespace Rows_Edit {
export type ActionData = {
updatedRow?: RowsApi.GetRowData;
deleted?: boolean;
error?: string;
errorCode?: import("~/utils/api/.server/RowsApi").RowApiErrorCode;
};
export type LoaderData = {
meta: MetaTagsDto;
rowData: RowsApi.GetRowData;
routes: EntitiesApi.Routes;
allEntities: EntityWithDetails[];
relationshipRows: RowsApi.GetRelationshipRowsData;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_Edit] ${params.entity}`);
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
const user = await time(getUser(userId), "getUser");
await time(verifyUserHasEntityPermission(request, entity, "update", tenantId), "verifyUserHasPermission");
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404?entity=" + params.entity);
}
const rowData = await time(
RowsApi.get(params.id!, {
entity,
tenantId,
userId,
}),
"RowsApi.get"
);
if (!rowData.rowPermissions.canUpdate && !user?.admin) {
throw Error(t("shared.unauthorized"));
}
const entityPluralLabel = translateEntityTitlePlural(t, i18next, entity);
const data: LoaderData = {
meta: [
{
title: `${t("shared.edit")} | ${RowHelper.getTextDescription({ entity, item: rowData.item, t })} | ${entityPluralLabel} | ${
process.env.APP_NAME
}`,
},
],
rowData,
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
allEntities: await time(getAllEntities({ tenantId }), "getAllEntities"),
relationshipRows: await time(RowsApi.getRelationshipRows({ entity, tenantId, userId }), "RowsApi.getRelationshipRows"),
};
return Response.json(data, { headers: getServerTimingHeader() });
};
export const action: ActionFunction = async ({ request, params }) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_Edit] ${params.entity}`);
const { t, userId, tenantId, entity, form } = await RowsRequestUtils.getAction({ request, params });
const user = await getUser(userId);
const { item } = await time(
RowsApi.get(params.id!, {
entity,
tenantId,
userId,
}),
"RowsApi.get"
);
const action = form.get("action");
let rowValues: any = {};
if (action === "edit") {
try {
rowValues = RowHelper.getRowPropertiesFromForm({ t, entity, form, existing: item });
const updatedRow = await time(
RowsApi.update(params.id!, {
entity,
request,
tenantId,
userId,
rowValues,
}),
"RowsApi.update"
);
await time(
FormulaService.trigger({ trigger: "AFTER_UPDATED", rows: [updatedRow], entity: entity, session: { tenantId, userId }, t }),
"FormulaService.trigger.AFTER_UPDATED"
);
} catch (error: unknown) {
return rowActionError(t, error, getServerTimingHeader());
}
const updatedRow = await RowsApi.get(params.id!, { entity, tenantId, userId });
if (item.createdByUser) {
rowsEditLogger.info({ createdByUser: item.createdByUser }, "Sending notification");
await NotificationService.send({
channel: "my-rows",
to: item.createdByUser,
tenantId,
notification: {
from: { user },
message: t("notifications.messages.row.updated", {
email: user?.email ?? t("shared.unknown"),
row: RowHelper.getTextDescription({ entity, item, t }),
}),
action: {
title: t("shared.view"),
url: EntityHelper.getRoutes({ routes: EntitiesApi.getNoCodeRoutes({ request, params }), entity, item })?.overview ?? "",
},
},
});
}
const redirectTo = form.get("redirect")?.toString() || new URL(request.url).searchParams.get("redirect")?.toString();
if (redirectTo) {
return redirect(safeRedirectPathFromRequest(request, redirectTo), { headers: getServerTimingHeader() });
}
return Response.json({ updatedRow } satisfies ActionData, { headers: getServerTimingHeader() });
} else if (action === "delete") {
try {
await time(verifyUserHasEntityPermission(request, entity, "delete", tenantId), "verifyUserHasPermission");
await RowsApi.del(params.id!, {
entity,
request,
tenantId,
userId,
checkPermissions: !user?.admin,
});
} catch (error: unknown) {
return rowActionError(t, error, getServerTimingHeader());
}
const redirectTo = form.get("redirect")?.toString() || new URL(request.url).searchParams.get("redirect")?.toString();
if (redirectTo) {
return redirect(safeRedirectPathFromRequest(request, redirectTo), { headers: getServerTimingHeader() });
}
return Response.json({ deleted: true } satisfies ActionData, { headers: getServerTimingHeader() });
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
};
}
function rowActionError(t: TFunction, error: unknown, headers: HeadersInit) {
return Response.json(
{ error: translateRowsRouteError(t, error), errorCode: getRowsRouteErrorCode(error) } satisfies Rows_Edit.ActionData,
{ status: getRowsRouteErrorStatus(error), headers }
);
}
@@ -0,0 +1,38 @@
import { readFileSync } from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
const routesDir = path.resolve("apps/web/app/modules/rows/routes");
const rowsApiSource = readFileSync(path.resolve("apps/web/app/utils/api/.server/RowsApi.ts"), "utf8");
const rowsErrorSource = readFileSync(path.join(routesDir, "Rows_Error.server.ts"), "utf8");
function readRoute(file: string) {
return readFileSync(path.join(routesDir, file), "utf8");
}
describe("Rows route error i18n mapping", () => {
it("maps stable row API error codes to i18n keys with an unexpected fallback", () => {
expect(rowsErrorSource).toContain("Record<RowApiErrorCode, string>");
expect(rowsErrorSource).toContain('"row-access-denied": "models.row.errors.accessDenied"');
expect(rowsErrorSource).toContain('"row-update-denied": "models.row.errors.updateDenied"');
expect(rowsErrorSource).toContain('"row-delete-denied": "models.row.errors.deleteDenied"');
expect(rowsErrorSource).toContain('t("shared.unexpectedError")');
});
it("does not return raw thrown messages from visible rows mutations", () => {
for (const file of ["Rows_Overview.server.ts", "Rows_List.server.tsx", "Rows_New.server.ts", "Rows_Edit.server.ts", "Rows_Share.server.ts", "Rows_Import.server.ts"]) {
const source = readRoute(file);
expect(source).not.toContain("error.message");
expect(source).not.toContain("e.message");
expect(source).toContain("translateRowsRouteError");
}
});
it("does not expose raw English row access errors from RowsApi", () => {
expect(rowsApiSource).not.toContain('Response.json({ error: "You don');
expect(rowsApiSource).toContain('rowApiError("row-access-denied", 403)');
expect(rowsApiSource).toContain('rowApiError("row-update-denied", 403)');
expect(rowsApiSource).toContain('rowApiError("row-delete-denied", 403)');
});
});
@@ -0,0 +1,28 @@
import type { TFunction } from "i18next";
import { RowsApi, type RowApiErrorCode } from "~/utils/api/.server/RowsApi";
const rowApiErrorKeys: Record<RowApiErrorCode, string> = {
"entity-not-found": "models.row.errors.entityNotFound",
"row-not-found": "models.row.errors.notFound",
"row-access-denied": "models.row.errors.accessDenied",
"row-update-denied": "models.row.errors.updateDenied",
"row-delete-denied": "models.row.errors.deleteDenied",
"permission-unknown": "models.row.errors.unknownPermission",
"permission-missing": "models.row.errors.missingPermission",
"usage-limit-disabled": "models.row.errors.usageLimitDisabled",
};
export function getRowsRouteErrorStatus(error: unknown) {
return RowsApi.isRowApiError(error) ? error.status : 400;
}
export function translateRowsRouteError(t: TFunction, error: unknown) {
if (!RowsApi.isRowApiError(error)) {
return t("shared.unexpectedError");
}
return t(rowApiErrorKeys[error.code], error.details ?? {});
}
export function getRowsRouteErrorCode(error: unknown) {
return RowsApi.isRowApiError(error) ? error.code : undefined;
}
@@ -0,0 +1,47 @@
import { LoaderFunctionArgs, redirect } from "react-router";
import { serializeExportTableToCsv } from "@toolctrl/exports/csv";
import Constants from "~/application/Constants";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import ApiHelper from "~/utils/helpers/ApiHelper";
import { getEntityPermission } from "~/utils/helpers/PermissionsHelper";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import i18next from "i18next";
import { translateEntityTitlePlural } from "~/utils/i18n/translateLabel";
export namespace Rows_Export {
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_Export] ${params.entity}`);
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
await time(verifyUserHasPermission(request, getEntityPermission(entity, "view"), tenantId), "verifyUserHasPermission");
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const rowsData = await time(
RowsApi.getAll({
entity,
tenantId,
userId,
urlSearchParams: new URL(request.url).searchParams,
pageSize: Constants.MAX_EXPORT_PAGE_SIZE,
time,
}),
"RowsApi.getAll"
);
const apiFormat = rowsData.items.map((item) => {
return ApiHelper.getApiFormat(entity, item);
});
const csv = serializeExportTableToCsv({ columns: entity.properties.map((f) => f.name), rows: apiFormat }, { delimiter: "|" });
const entityPluralLabel = translateEntityTitlePlural(t, i18next, entity);
return new Response(csv, {
status: 200,
headers: {
"Content-Type": "text/csv",
"Content-Disposition": `attachment; filename=${entityPluralLabel}.csv`,
...getServerTimingHeader(),
},
});
};
}
@@ -0,0 +1,125 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { Rows_Import } from "./Rows_Import.server";
const getActionMock = vi.fn();
const verifyUserHasEntityPermissionMock = vi.fn();
const rowsCreateMock = vi.fn();
const rowsAddTagMock = vi.fn();
const getMaxRowFolioMock = vi.fn();
const getRowByIdMock = vi.fn();
vi.mock("../utils/RowsRequestUtils", () => ({
default: {
getAction: (...args: unknown[]) => getActionMock(...args),
},
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasEntityPermission: (...args: unknown[]) => verifyUserHasEntityPermissionMock(...args),
}));
vi.mock("~/utils/api/.server/RowsApi", () => ({
RowsApi: {
create: (...args: unknown[]) => rowsCreateMock(...args),
addTag: (...args: unknown[]) => rowsAddTagMock(...args),
},
}));
vi.mock("~/utils/db/entities/rows.db.server", () => ({
getMaxRowFolio: (...args: unknown[]) => getMaxRowFolioMock(...args),
getRowById: (...args: unknown[]) => getRowByIdMock(...args),
}));
vi.mock("~/utils/helpers/RowHelper", () => ({
default: {
getRowPropertiesFromForm: vi.fn(({ values }) => values),
},
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
adminGetAllTenantsIdsAndNames: vi.fn(),
getTenant: vi.fn(),
}));
function buildForm(rows: number) {
const form = new FormData();
form.set("action", "import");
for (let index = 0; index < rows; index += 1) {
form.append("rows[]", JSON.stringify({ properties: [{ name: "name", value: `Row ${index + 1}` }] }));
}
return form;
}
function mockActionContext(form: FormData) {
getActionMock.mockResolvedValue({
t: (key: string, values?: Record<string, unknown>) => (values ? `${key}:${JSON.stringify(values)}` : key),
userId: "user-1",
tenantId: "tenant-1",
entity: { id: "entity-1", name: "contacts", titlePlural: "Contacts", isAutogenerated: true, type: "app" },
form,
});
}
function delay(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
describe("Rows_Import.action", () => {
beforeEach(() => {
vi.clearAllMocks();
verifyUserHasEntityPermissionMock.mockResolvedValue(undefined);
rowsAddTagMock.mockResolvedValue(undefined);
getMaxRowFolioMock.mockResolvedValue({ _max: { folio: 10 } });
getRowByIdMock.mockImplementation(async (id: string) => ({ id }));
});
it("rejects oversized import requests before creating rows", async () => {
mockActionContext(buildForm(Rows_Import.MAX_IMPORT_ROWS + 1));
const response = await Rows_Import.action({
request: new Request("http://localhost/import", { method: "POST" }),
params: {},
context: {},
});
expect(response).toBeInstanceOf(Response);
expect((response as Response).status).toBe(400);
await expect((response as Response).json()).resolves.toMatchObject({
error: expect.stringContaining("models.row.import.errors.tooManyRows"),
});
expect(rowsCreateMock).not.toHaveBeenCalled();
});
it("imports rows with bounded concurrency while preserving response order", async () => {
mockActionContext(buildForm(8));
let active = 0;
let maxActive = 0;
rowsCreateMock.mockImplementation(async ({ nextFolio }: { nextFolio: number }) => {
active += 1;
maxActive = Math.max(maxActive, active);
await delay(5);
active -= 1;
return { id: `row-${nextFolio}` };
});
const result = await Rows_Import.action({
request: new Request("http://localhost/import", { method: "POST" }),
params: {},
context: {},
});
expect(result).not.toBeInstanceOf(Response);
expect(rowsCreateMock).toHaveBeenCalledTimes(8);
expect(maxActive).toBeLessThanOrEqual(5);
expect((result as Rows_Import.ActionData).rows?.map((row) => row.row?.id)).toEqual([
"row-11",
"row-12",
"row-13",
"row-14",
"row-15",
"row-16",
"row-17",
"row-18",
]);
});
});
@@ -0,0 +1,127 @@
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import { mapWithConcurrency } from "@toolctrl/foundation";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { Colors } from "~/application/enums/shared/Colors";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { EntityWithDetails } from "~/utils/db/entities/entities.db.server";
import { getMaxRowFolio, getRowById, RowWithDetails } from "~/utils/db/entities/rows.db.server";
import RowHelper from "~/utils/helpers/RowHelper";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import { adminGetAllTenantsIdsAndNames, getTenant } from "~/utils/db/tenants.db.server";
import { verifyUserHasEntityPermission } from "~/utils/helpers/.server/PermissionsService";
import i18next from "i18next";
import { translateEntityTitlePlural } from "~/utils/i18n/translateLabel";
import { translateRowsRouteError } from "./Rows_Error.server";
export namespace Rows_Import {
export const MAX_IMPORT_ROWS = 500;
const IMPORT_ROW_CONCURRENCY = 5;
export type LoaderData = {
meta: MetaTagsDto;
entity: EntityWithDetails;
allTenants: { id: string; name: string; slug: string }[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const entityPluralLabel = translateEntityTitlePlural(t, i18next, entity);
const data: LoaderData = {
meta: [{ title: `${t("shared.import")} ${entityPluralLabel} | ${process.env.APP_NAME}` }],
entity,
allTenants: !tenantId ? await adminGetAllTenantsIdsAndNames() : [],
};
return Response.json(data);
};
export interface ImportRow {
properties: { name: string; value: string }[];
row?: RowWithDetails | null;
error?: string;
}
export type ActionData = {
rows?: ImportRow[];
error?: string;
};
export const action: ActionFunction = async ({ request, params }) => {
const { t, userId, tenantId, entity, form } = await RowsRequestUtils.getAction({ request, params });
const action = form.get("action");
if (action === "import") {
await verifyUserHasEntityPermission(request, entity, "create", tenantId);
const tag = form.get("tag")?.toString() ?? t("models.row.import.defaultTag");
const rawRows: ImportRow[] = form.getAll("rows[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
let tenantToImport = tenantId;
if (tenantId === null) {
const selectedTenantId = form.get("selectedTenantId")?.toString() || "{null}";
if (selectedTenantId === "{null}") {
tenantToImport = null;
} else {
const existingTenant = await getTenant(selectedTenantId);
if (!existingTenant) {
return Response.json(
{
error: t("models.row.import.errors.invalidTenantId", { tenantId: selectedTenantId }),
},
{ status: 400 }
);
}
tenantToImport = selectedTenantId;
}
}
if (rawRows.length === 0) {
return Response.json(
{ error: t("models.row.import.errors.noRowsToImport") },
{ status: 400 }
);
}
if (rawRows.length > MAX_IMPORT_ROWS) {
return Response.json(
{ error: t("models.row.import.errors.tooManyRows", { count: rawRows.length, max: MAX_IMPORT_ROWS }) },
{ status: 400 }
);
}
const rows: ImportRow[] = new Array(rawRows.length);
let folio = 1;
const maxFolio = await getMaxRowFolio({ tenantId: tenantToImport, entityId: entity.id });
if (maxFolio && maxFolio._max.folio !== null) {
folio = maxFolio._max.folio + 1;
}
await mapWithConcurrency(
rawRows.map((importRow, idx) => ({ importRow, idx })),
IMPORT_ROW_CONCURRENCY,
async ({ importRow, idx }) => {
try {
const rowValues = RowHelper.getRowPropertiesFromForm({ t, entity, values: importRow.properties });
const newRow = await RowsApi.create({
entity,
tenantId: tenantToImport,
userId,
rowValues,
nextFolio: folio + idx,
request,
});
if (tag) {
await RowsApi.addTag({ row: newRow, tag: { value: tag, color: Colors.INDIGO } });
}
importRow.row = await getRowById(newRow.id, { entityId: entity.id, tenantId: tenantToImport });
} catch (e: unknown) {
importRow.error = translateRowsRouteError(t, e);
}
rows[idx] = importRow;
}
);
const data: ActionData = {
rows,
};
return data;
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
};
}
@@ -0,0 +1,18 @@
import { readFileSync } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { describe, expect, it } from "vitest";
function readRouteSource() {
return readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "Rows_List.server.tsx"), "utf8");
}
describe("Rows_List mutation permissions", () => {
it("requires entity update permission for view and order mutations", () => {
const source = readRouteSource();
expect(source).toContain('["view-create", "view-edit", "view-delete", "move-up", "move-down"].includes(action)');
expect(source).toContain('verifyUserHasEntityPermission(request, entity, "update", tenantId)');
expect(source.indexOf("verifyUserHasPermission.update")).toBeLessThan(source.indexOf('if (action === "view-create")'));
});
});
@@ -0,0 +1,20 @@
// @vitest-environment node
import { readFileSync } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { describe, expect, it } from "vitest";
const appDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
const rowsListSource = readFileSync(path.join(appDir, "modules/rows/routes/Rows_List.server.tsx"), "utf8");
const entityViewsApiSource = readFileSync(path.join(appDir, "utils/api/.server/EntityViewsApi.ts"), "utf8");
describe("Rows_List view mutations", () => {
it("loads and mutates entity views through scoped helpers", () => {
expect(rowsListSource).toContain("getEntityView(id, { entityId: entity.id, tenantId, userId })");
expect(rowsListSource).toContain("deleteScopedEntityView({ id: item.id, entityId: entity.id, tenantId, userId: item.userId })");
expect(entityViewsApiSource).toContain("updateScopedEntityView(viewScope");
expect(entityViewsApiSource).toContain("updateScopedEntityViewProperties(viewScope");
expect(entityViewsApiSource).toContain("updateScopedEntityViewFilters(viewScope");
expect(entityViewsApiSource).toContain("updateScopedEntityViewSort(viewScope");
});
});
@@ -0,0 +1,144 @@
import { ActionFunction, LoaderFunctionArgs, redirect } from "react-router";
import type { TFunction } from "i18next";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import { verifyUserHasEntityPermission } from "~/utils/helpers/.server/PermissionsService";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { EntityViewsApi } from "~/utils/api/.server/EntityViewsApi";
import { deleteScopedEntityView, getEntityView } from "~/utils/db/entities/entityViews.db.server";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import FormulaService from "~/modules/formulas/services/.server/FormulaService";
import { EntityView } from "@toolctrl/db/prisma-browser";
import { getRowsInIds } from "~/utils/db/entities/rows.db.server";
import i18next from "i18next";
import { translateEntityTitlePlural } from "~/utils/i18n/translateLabel";
import { getRowsRouteErrorCode, getRowsRouteErrorStatus, translateRowsRouteError } from "./Rows_Error.server";
export namespace Rows_List {
export type LoaderData = {
meta: MetaTagsDto;
rowsData: RowsApi.GetRowsData;
routes: EntitiesApi.Routes;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_List] ${params.entity}`);
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
await time(verifyUserHasEntityPermission(request, entity, "view", tenantId), "verifyUserHasPermission");
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const rowsData = await time(
RowsApi.getAll({
entity,
tenantId,
userId,
urlSearchParams: new URL(request.url).searchParams,
time,
}),
"RowsApi.getAll"
);
await time(
FormulaService.trigger({ trigger: "BEFORE_LISTED", rows: rowsData.items, entity: rowsData.entity, session: { tenantId, userId }, t }),
"FormulaService.trigger.BEFORE_LISTED"
);
const entityPluralLabel = translateEntityTitlePlural(t, i18next, entity);
const data: LoaderData = {
meta: [{ title: `${entityPluralLabel} | ${process.env.APP_NAME}` }],
rowsData,
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
};
return Response.json(data, { headers: getServerTimingHeader() });
};
export type ActionData = {
success?: string;
error?: string;
errorCode?: import("~/utils/api/.server/RowsApi").RowApiErrorCode;
updatedView?: EntityView;
rowsDeleted?: string[];
};
export const action: ActionFunction = async ({ request, params }) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_List] ${params.entity}`);
const { t, userId, tenantId, entity, form } = await RowsRequestUtils.getAction({ request, params });
const action = form.get("action")?.toString() ?? "";
const requiresEntityUpdate = ["view-create", "view-edit", "view-delete", "move-up", "move-down"].includes(action);
if (requiresEntityUpdate) {
await time(verifyUserHasEntityPermission(request, entity, "update", tenantId), "verifyUserHasPermission.update");
}
if (action === "view-create") {
try {
form.set("tenantId", tenantId ?? "");
form.set("userId", "");
const view = await time(EntityViewsApi.createFromForm({ entity, form, createdByUserId: userId }), "EntityViewsApi.createFromForm");
return redirect(new URL(request.url, request.url).pathname + "?v=" + view.name, { headers: getServerTimingHeader() });
} catch (e: unknown) {
return rowActionError(t, e, getServerTimingHeader());
}
} else if (action === "view-edit" || action === "view-delete") {
const id = form.get("id")?.toString() ?? "";
const item = await time(getEntityView(id, { entityId: entity.id, tenantId, userId }), "getEntityView");
if (!item || item.entityId !== entity.id || item.tenantId !== tenantId || item.isSystem || (item.userId && item.userId !== userId)) {
return Response.json({ error: t("shared.notFound") }, { status: 400, headers: getServerTimingHeader() });
}
try {
if (action === "view-edit") {
const updatedView = await time(EntityViewsApi.updateFromForm({ entity, item, form }), "EntityViewsApi.updateFromForm");
const actionData: ActionData = {
updatedView,
};
return Response.json(actionData, { headers: getServerTimingHeader() });
} else {
await time(deleteScopedEntityView({ id: item.id, entityId: entity.id, tenantId, userId: item.userId }), "deleteEntityView");
return redirect(new URL(request.url, request.url).pathname + "?v=", { headers: getServerTimingHeader() });
}
} catch (e: unknown) {
return rowActionError(t, e, getServerTimingHeader());
}
} else if (["move-up", "move-down"].includes(action)) {
const id = form.get("id")?.toString() ?? "";
await time(
RowsApi.changeOrder(
{ id, entityId: entity.id, tenantId },
{
target: action === "move-up" ? "up" : "down",
}
),
"RowsApi.changeOrder"
);
return Response.json({}, { headers: getServerTimingHeader() });
} else if (action === "bulk-delete") {
if (!entity.hasBulkDelete) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
const rowIds = form.getAll("rowIds[]") as string[];
try {
const rows = await getRowsInIds(rowIds, tenantId);
const inexistentRows = rowIds.filter((id) => !rows.find((f) => f.id === id && f.entityId === entity.id && f.tenantId === tenantId));
if (inexistentRows.length > 0) {
return Response.json({ error: t("shared.notFound") }, { status: 400, headers: getServerTimingHeader() });
}
const rowsDeleted: string[] = [];
await Promise.all(
rows.map(async (row) => {
const deleted = await RowsApi.del(row.id, { entity, request, tenantId, userId });
rowsDeleted.push(deleted.id);
})
);
return Response.json({ success: t("shared.deleted"), rowsDeleted }, { headers: getServerTimingHeader() });
} catch (e: unknown) {
return rowActionError(t, e, getServerTimingHeader());
}
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
};
}
function rowActionError(t: TFunction, error: unknown, headers: HeadersInit) {
return Response.json(
{ error: translateRowsRouteError(t, error), errorCode: getRowsRouteErrorCode(error) } satisfies Rows_List.ActionData,
{ status: getRowsRouteErrorStatus(error), headers }
);
}
@@ -0,0 +1,122 @@
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import type { TFunction } from "i18next";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { EntityWithDetails, getAllEntities } from "~/utils/db/entities/entities.db.server";
import EntityHelper from "~/utils/helpers/EntityHelper";
import { verifyUserHasEntityPermission } from "~/utils/helpers/.server/PermissionsService";
import RowHelper from "~/utils/helpers/RowHelper";
import { getUserInfo } from "~/utils/session.server";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import FormulaService from "~/modules/formulas/services/.server/FormulaService";
import { RowWithDetails } from "~/utils/db/entities/rows.db.server";
import { safeRedirectPathFromRequest } from "~/utils/app/RedirectSafety.server";
import i18next from "i18next";
import { translateEntityTitle } from "~/utils/i18n/translateLabel";
import { getRowsRouteErrorCode, getRowsRouteErrorStatus, translateRowsRouteError } from "./Rows_Error.server";
export namespace Rows_New {
export type LoaderData = {
meta: MetaTagsDto;
entityData: EntitiesApi.GetEntityData;
routes: EntitiesApi.Routes;
allEntities: EntityWithDetails[];
relationshipRows: RowsApi.GetRelationshipRowsData;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_New] ${params.entity}`);
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404", { status: 404, headers: getServerTimingHeader() });
}
const entityData = await time(
EntitiesApi.get({
entity,
tenantId,
userId,
}),
"EntitiesApi"
);
await time(verifyUserHasEntityPermission(request, entity, "create", tenantId), "verifyUserHasPermission");
const entityLabel = translateEntityTitle(t, i18next, entity);
const data: LoaderData = {
meta: [{ title: `${t("shared.create")} ${entityLabel} | ${process.env.APP_NAME}` }],
entityData,
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
allEntities: await time(getAllEntities({ tenantId, active: true }), "getAllEntities"),
relationshipRows: await time(RowsApi.getRelationshipRows({ entity, tenantId, userId }), "RowsApi.getRelationshipRows"),
};
return Response.json(data, { headers: getServerTimingHeader() });
};
export type ActionData = {
saveAndAdd?: boolean;
newRow?: RowWithDetails;
error?: string;
errorCode?: import("~/utils/api/.server/RowsApi").RowApiErrorCode;
};
export const action: ActionFunction = async ({ request, params }) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_New] ${params.entity}`);
const { t, userId, tenantId, entity, form } = await RowsRequestUtils.getAction({ request, params });
const action = form.get("action");
if (action === "create") {
try {
await time(verifyUserHasEntityPermission(request, entity, "create", tenantId), "verifyUserHasPermission");
const rowValues = RowHelper.getRowPropertiesFromForm({ t: t, entity, form });
const newRow = await time(
RowsApi.create({
entity,
tenantId,
userId: (await getUserInfo(request)).userId,
rowValues,
request,
}),
"RowsApi.create"
);
await time(
FormulaService.trigger({ trigger: "AFTER_CREATED", rows: [newRow], entity: entity, session: { tenantId, userId }, t }),
"FormulaService.trigger.AFTER_CREATED"
);
const onCreatedRedirect = form.get("onCreatedRedirect");
if (onCreatedRedirect) {
if (onCreatedRedirect === "addAnother") {
return Response.json({ saveAndAdd: true, newRow, headers: getServerTimingHeader() });
}
const routes = EntityHelper.getRoutes({ routes: EntitiesApi.getNoCodeRoutes({ request, params }), entity, item: newRow });
if (routes) {
if (!entity.onCreated || entity.onCreated === "redirectToOverview") {
return redirect(routes?.overview ?? "", { headers: getServerTimingHeader() });
} else if (entity.onCreated === "redirectToEdit") {
return redirect(routes?.edit ?? "", { headers: getServerTimingHeader() });
} else if (entity.onCreated === "redirectToList") {
return redirect(routes?.list ?? "", { headers: getServerTimingHeader() });
} else if (entity.onCreated === "redirectToNew") {
return Response.json({ newRow, replace: true }, { headers: getServerTimingHeader() });
} else if (params.group && entity.onCreated === "redirectToGroup") {
return redirect(routes?.group ?? "", { headers: getServerTimingHeader() });
}
}
}
const redirectTo = form.get("redirect")?.toString() || new URL(request.url).searchParams.get("redirect")?.toString();
if (redirectTo) {
return redirect(safeRedirectPathFromRequest(request, redirectTo), { headers: getServerTimingHeader() });
}
return Response.json({ newRow, headers: getServerTimingHeader() });
} catch (error: unknown) {
return rowActionError(t, error, getServerTimingHeader());
}
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
};
}
function rowActionError(t: TFunction, error: unknown, headers: HeadersInit) {
return Response.json(
{ error: translateRowsRouteError(t, error), errorCode: getRowsRouteErrorCode(error) } satisfies Rows_New.ActionData,
{ status: getRowsRouteErrorStatus(error), headers }
);
}
@@ -0,0 +1,35 @@
import fs from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
const source = fs.readFileSync(path.resolve("apps/web/app/modules/rows/routes/Rows_Overview.server.ts"), "utf8");
describe("Rows_Overview action permission gates", () => {
it("uses delete permission for row delete actions", () => {
expect(source).toContain('getEntityPermission(entity, "delete")');
expect(source).not.toContain('getEntityPermission(entity, "create"), tenantId), "verifyUserHasPermission"');
});
it("requires row comment permission before comment mutations", () => {
expect(source).toContain('action === "comment"');
expect(source).toContain("!rowData.rowPermissions.canComment");
expect(source).toContain('action === "comment-reaction"');
});
it("requires row update permission before task mutations", () => {
expect(source).toContain('action === "task-new"');
expect(source).toContain('action === "task-complete-toggle"');
expect(source).toContain('action === "task-delete"');
expect(source.match(/!rowData\.rowPermissions\.canUpdate/g)?.length ?? 0).toBeGreaterThanOrEqual(4);
});
it("scopes comment and task lookups to the current row before mutation", () => {
expect(source).toContain("getRowCommentInRow({ id: rowCommentId, rowId: item.id })");
expect(source).toContain("updateRowCommentInRow({ id: comment.id, rowId: item.id }");
expect(source).toContain("getRowTaskInRow({ id: taskId, rowId: item.id })");
expect(source).toMatch(/updateRowTaskInRow\(\s*\{\s*id: taskId,\s*rowId: item\.id\s*\}/);
expect(source).toContain("deleteRowTaskInRow({ id: taskId, rowId: item.id })");
expect(source).not.toContain("getRowComment(rowCommentId)");
expect(source).not.toContain("getRowTask(taskId)");
});
});
@@ -0,0 +1,380 @@
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import type { TFunction } from "i18next";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import NotificationService from "~/modules/notifications/services/.server/NotificationService";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import { RowCommentsApi } from "~/utils/api/.server/RowCommentsApi";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { setRowCommentReaction } from "~/utils/db/entities/rowCommentReaction.db.server";
import { getRowCommentInRow, updateRowCommentInRow } from "~/utils/db/entities/rowComments.db.server";
import { createRowTask, deleteRowTaskInRow, getRowTaskInRow, updateRowTaskInRow } from "~/utils/db/entities/rowTasks.db.server";
import { getUser } from "~/utils/db/users.db.server";
import EntityHelper from "~/utils/helpers/EntityHelper";
import { getEntityPermission } from "~/utils/helpers/PermissionsHelper";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import RowHelper from "~/utils/helpers/RowHelper";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import FormulaService from "~/modules/formulas/services/.server/FormulaService";
import EventsService from "~/modules/events/services/.server/EventsService";
import { RowTasksCreatedDto } from "~/modules/events/dtos/RowTasksCreatedDto";
import { RowTasksUpdatedDto } from "~/modules/events/dtos/RowTasksUpdatedDto";
import { RowTasksDeletedDto } from "~/modules/events/dtos/RowTasksDeletedDto";
import { RowCommentsCreatedDto } from "~/modules/events/dtos/RowCommentsCreatedDto";
import { RowCommentsReactedDto } from "~/modules/events/dtos/RowCommentsReactedDto";
import { RowCommentsDeletedDto } from "~/modules/events/dtos/RowCommentsDeletedDto";
import { safeRedirectPathFromRequest } from "~/utils/app/RedirectSafety.server";
import i18next from "i18next";
import { translateEntityTitlePlural } from "~/utils/i18n/translateLabel";
import { getRowsRouteErrorCode, getRowsRouteErrorStatus, translateRowsRouteError } from "./Rows_Error.server";
export namespace Rows_Overview {
export type LoaderData = {
meta: MetaTagsDto;
rowData: RowsApi.GetRowData;
routes: EntitiesApi.Routes;
relationshipRows: RowsApi.GetRelationshipRowsData;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_Overview] ${params.entity}`);
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
await time(verifyUserHasPermission(request, getEntityPermission(entity, "read"), tenantId), "verifyUserHasPermission");
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const rowData = await time(
RowsApi.get(params.id!, {
entity,
tenantId,
userId,
}),
"RowsApi.get"
);
await time(
FormulaService.trigger({ trigger: "BEFORE_VIEWED", rows: [rowData.item], entity: rowData.entity, session: { tenantId, userId }, t }),
"FormulaService.trigger.BEFORE_VIEWED"
);
const entityPluralLabel = translateEntityTitlePlural(t, i18next, entity);
const data: LoaderData = {
meta: [{ title: `${RowHelper.getTextDescription({ entity, item: rowData.item, t })} | ${entityPluralLabel} | ${process.env.APP_NAME}` }],
rowData,
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
relationshipRows: await time(RowsApi.getRelationshipRows({ entity, tenantId, userId }), "RowsApi.getRelationshipRows"),
};
return Response.json(data, { headers: getServerTimingHeader() });
};
export type ActionData = {
updatedRow?: RowsApi.GetRowData;
success?: string;
error?: string;
errorCode?: import("~/utils/api/.server/RowsApi").RowApiErrorCode;
};
export const action: ActionFunction = async ({ request, params }) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_Overview] ${params.entity}`);
const { t, userId, tenantId, entity, form } = await RowsRequestUtils.getAction({ request, params });
const action = form.get("action")?.toString() ?? "";
const user = await time(getUser(userId), "getUser");
const rowData = await time(
RowsApi.get(params.id!, {
entity,
tenantId,
userId,
}),
"RowsApi.get"
);
const { item } = rowData;
if (action === "edit") {
try {
const rowValues = RowHelper.getRowPropertiesFromForm({ t, entity, form, existing: item });
await time(
RowsApi.update(params.id!, {
entity,
request,
tenantId,
userId,
rowValues,
}),
"RowsApi.update"
);
} catch (error: unknown) {
return rowActionError(t, error, getServerTimingHeader());
}
// const redirectTo = form.get("redirect")?.toString() || new URL(request.url).searchParams.get("redirect")?.toString();
// if (redirectTo) {
// return redirect(redirectTo, { headers: getServerTimingHeader() });
// }
const updatedRow = await time(RowsApi.get(params.id!, { entity, tenantId, userId }), "RowsApi.get");
return Response.json({ updatedRow, success: t("shared.saved") }, { headers: getServerTimingHeader() });
} else if (action === "delete") {
try {
await time(verifyUserHasPermission(request, getEntityPermission(entity, "delete"), tenantId), "verifyUserHasPermission");
await time(
RowsApi.del(params.id!, {
entity,
request,
tenantId,
userId,
}),
"RowsApi.del"
);
if (item.createdByUser) {
await time(
NotificationService.send({
channel: "my-rows",
to: item.createdByUser,
tenantId,
notification: {
from: { user },
message: t("notifications.messages.row.deleted", {
email: user?.email ?? t("shared.unknown"),
row: RowHelper.getTextDescription({ entity, item, t }),
}),
action: {
title: t("shared.view"),
url: EntityHelper.getRoutes({ routes: EntitiesApi.getNoCodeRoutes({ request, params }), entity, item })?.overview ?? "",
},
},
}),
"NotificationService.send"
);
}
} catch (error: unknown) {
return rowActionError(t, error, getServerTimingHeader());
}
const redirectTo = form.get("redirect")?.toString() || new URL(request.url).searchParams.get("redirect")?.toString();
if (redirectTo) {
return redirect(safeRedirectPathFromRequest(request, redirectTo), { headers: getServerTimingHeader() });
}
const routes = EntitiesApi.getNoCodeRoutes({ request, params });
const listRoute = EntityHelper.getRoutes({ routes, entity })?.list;
if (listRoute) {
return redirect(listRoute, { headers: getServerTimingHeader() });
}
return Response.json({ deleted: true }, { headers: getServerTimingHeader() });
} else if (action === "comment") {
if (!rowData.rowPermissions.canComment) {
return rowActionForbidden(t, getServerTimingHeader());
}
let comment = form.get("comment")?.toString();
if (!comment) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
await time(
RowCommentsApi.create(item.id, {
comment,
tenantId,
userId,
}),
"RowCommentsApi.create"
);
await EventsService.create({
request,
event: "row.comments.created",
tenantId,
userId,
data: {
rowId: item.id,
comment: { id: item.id, text: comment },
user: !user ? null : { id: user.id, email: user.email },
} satisfies RowCommentsCreatedDto,
});
if (item.createdByUser) {
await time(
NotificationService.send({
channel: "my-rows",
to: item.createdByUser,
tenantId,
notification: {
from: { user },
message: t("notifications.messages.row.commented", {
email: user?.email ?? t("shared.unknown"),
row: RowHelper.getTextDescription({ entity, item, t }),
}),
action: {
title: t("shared.view"),
url: EntityHelper.getRoutes({ routes: EntitiesApi.getNoCodeRoutes({ request, params }), entity, item })?.overview ?? "",
},
},
}),
"NotificationService.send"
);
}
return Response.json({ newComment: comment }, { headers: getServerTimingHeader() });
} else if (action === "comment-reaction") {
if (!rowData.rowPermissions.canComment) {
return rowActionForbidden(t, getServerTimingHeader());
}
const rowCommentId = form.get("comment-id")?.toString();
const reaction = form.get("reaction")?.toString();
if (!rowCommentId || !reaction) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
const comment = await time(getRowCommentInRow({ id: rowCommentId, rowId: item.id }), "getRowCommentInRow");
if (!comment) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
if (comment) {
await time(
setRowCommentReaction({
createdByUserId: userId,
rowCommentId,
reaction,
}),
"setRowCommentReaction"
);
await EventsService.create({
request,
event: "row.comments.reacted",
tenantId,
userId,
data: {
rowId: item.id,
comment: { id: comment.id, text: comment.value },
reaction,
user: !user ? null : { id: user.id, email: user.email },
} satisfies RowCommentsReactedDto,
});
}
return Response.json({ newCommentReaction: reaction }, { headers: getServerTimingHeader() });
} else if (action === "comment-delete") {
const rowCommentId = form.get("comment-id")?.toString() ?? "";
const comment = await getRowCommentInRow({ id: rowCommentId, rowId: item.id });
if (!comment) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
if (!rowData.rowPermissions.canUpdate && comment.createdByUserId !== userId) {
return rowActionForbidden(t, getServerTimingHeader());
}
await time(updateRowCommentInRow({ id: comment.id, rowId: item.id }, { isDeleted: true }), "updateRowCommentInRow");
await EventsService.create({
request,
event: "row.comments.deleted",
tenantId,
userId,
data: {
rowId: item.id,
comment: { id: comment.id, text: comment.value },
user: !user ? null : { id: user.id, email: user.email },
} satisfies RowCommentsDeletedDto,
});
return Response.json({ deletedComment: rowCommentId }, { headers: getServerTimingHeader() });
} else if (action === "task-new") {
if (!rowData.rowPermissions.canUpdate) {
return rowActionForbidden(t, getServerTimingHeader());
}
const taskTitle = form.get("task-title")?.toString();
if (!taskTitle) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
const task = await time(
createRowTask({
createdByUserId: userId,
rowId: item.id,
title: taskTitle,
}),
"createRowTask"
);
await EventsService.create({
request,
event: "row.tasks.created",
tenantId,
userId,
data: {
rowId: item.id,
task: { id: task.id, name: task.title },
user: !user ? null : { id: user.id, email: user.email },
} satisfies RowTasksCreatedDto,
});
return Response.json({ newTask: task }, { headers: getServerTimingHeader() });
} else if (action === "task-complete-toggle") {
if (!rowData.rowPermissions.canUpdate) {
return rowActionForbidden(t, getServerTimingHeader());
}
const taskId = form.get("task-id")?.toString() ?? "";
const task = await time(getRowTaskInRow({ id: taskId, rowId: item.id }), "getRowTaskInRow");
if (!task) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
if (task) {
if (task.completed) {
await time(
updateRowTaskInRow(
{ id: taskId, rowId: item.id },
{
completed: false,
completedAt: null,
completedByUserId: null,
}
),
"updateRowTask"
);
} else {
await time(
updateRowTaskInRow(
{ id: taskId, rowId: item.id },
{
completed: true,
completedAt: new Date(),
completedByUserId: userId,
}
),
"updateRowTask"
);
}
await EventsService.create({
request,
event: "row.tasks.created",
tenantId,
userId,
data: {
rowId: item.id,
old: { id: task.id, name: task.title, completedAt: task.completedAt },
new: { id: task.id, name: task.title, completedAt: task.completed ? new Date() : null },
user: !user ? null : { id: user.id, email: user.email },
} satisfies RowTasksUpdatedDto,
});
}
return Response.json({ completedTask: taskId }, { headers: getServerTimingHeader() });
} else if (action === "task-delete") {
if (!rowData.rowPermissions.canUpdate) {
return rowActionForbidden(t, getServerTimingHeader());
}
const taskId = form.get("task-id")?.toString() ?? "";
const task = await time(getRowTaskInRow({ id: taskId, rowId: item.id }), "getRowTaskInRow");
if (!task) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
if (task) {
await time(deleteRowTaskInRow({ id: taskId, rowId: item.id }), "deleteRowTaskInRow");
await EventsService.create({
request,
event: "row.tasks.deleted",
tenantId,
userId,
data: {
rowId: item.id,
task: { id: task.id, name: task.title },
user: !user ? null : { id: user.id, email: user.email },
} satisfies RowTasksDeletedDto,
});
}
return Response.json({ deletedTask: taskId }, { headers: getServerTimingHeader() });
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400, headers: getServerTimingHeader() });
}
};
}
function rowActionForbidden(t: TFunction, headers: HeadersInit) {
return Response.json({ error: t("foundation.errors.forbidden") }, { status: 403, headers });
}
function rowActionError(t: TFunction, error: unknown, headers: HeadersInit) {
return Response.json(
{ error: translateRowsRouteError(t, error), errorCode: getRowsRouteErrorCode(error) } satisfies Rows_Overview.ActionData,
{ status: getRowsRouteErrorStatus(error), headers }
);
}
@@ -0,0 +1,64 @@
import { LoaderFunctionArgs, redirect } from "react-router";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { verifyUserHasEntityPermission } from "~/utils/helpers/.server/PermissionsService";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
export namespace Rows_Relationships {
export type LoaderData = {
entitiesData: { rowsData: RowsApi.GetRowsData }[];
routes: EntitiesApi.Routes;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, `[Rows_Relationships] ${params.entity}`);
const { userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
await time(verifyUserHasEntityPermission(request, entity, "view", tenantId), "verifyUserHasPermission");
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const entitiesData: {
rowsData: RowsApi.GetRowsData;
}[] = [];
async function getRowsData(entity: { id?: string; name?: string }) {
return await RowsApi.getAll({
entity,
tenantId,
userId,
urlSearchParams: new URL(request.url).searchParams,
});
}
await time(
Promise.all(
entity.parentEntities.map(async (relationship) => {
entitiesData.push({
rowsData: await getRowsData({ name: relationship.parent.name }),
});
})
),
"parentEntities.getRowsData"
);
entitiesData.push({
rowsData: await time(getRowsData({ name: entity.name }), "getRowsData"),
});
await time(
Promise.all(
entity.childEntities.map(async (relationship) => {
entitiesData.push({
rowsData: await getRowsData({ name: relationship.child.name }),
});
})
),
"childEntities.getRowsData"
);
const data: LoaderData = {
entitiesData: entitiesData.sort((a, b) => (a.rowsData.entity.order > b.rowsData.entity.order ? 1 : -1)),
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
};
return Response.json(data, { headers: getServerTimingHeader() });
};
}
@@ -0,0 +1,17 @@
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { describe, expect, it } from "vitest";
const repoRoot = process.cwd();
describe("row share public route boundary", () => {
it("does not accept public share targets after public row routes were removed", () => {
const routeSource = readFileSync(join(repoRoot, "apps/web/app/modules/rows/routes/Rows_Share.server.ts"), "utf8");
const generatedShareSource = readFileSync(join(repoRoot, "apps/web/app/modules/codeGenerator/templates/routes/api/CodeTemplate.Routes.Share.Api.ts"), "utf8");
expect(routeSource).toContain('const allowedShareTypes = ["tenant", "user", "role", "group"] as const');
expect(routeSource).not.toContain('"tenant" | "user" | "role" | "group" | "public"');
expect(generatedShareSource).toContain('const allowedShareTypes = ["tenant", "user", "role", "group"] as const');
expect(generatedShareSource).not.toContain('"tenant" | "user" | "role" | "group" | "public"');
});
});
@@ -0,0 +1,141 @@
import { Tenant } from "@toolctrl/db/prisma-browser";
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import type { TFunction } from "i18next";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { RowAccess } from "~/application/enums/entities/RowAccess";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import { RowPermissionsApi } from "~/utils/api/.server/RowPermissionsApi";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { adminGetAllTenants, getTenant } from "~/utils/db/tenants.db.server";
import { UserWithDetails, getUser, getUsersByTenant } from "~/utils/db/users.db.server";
import RowHelper from "~/utils/helpers/RowHelper";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import EventsService from "~/modules/events/services/.server/EventsService";
import { RowSharedDto } from "~/modules/events/dtos/RowSharedDto";
import { getRowsRouteErrorCode, getRowsRouteErrorStatus, translateRowsRouteError } from "./Rows_Error.server";
const allowedShareTypes = ["tenant", "user", "role", "group"] as const;
type ShareType = (typeof allowedShareTypes)[number];
function getShareType(value: FormDataEntryValue | null): ShareType | null {
const type = value?.toString();
return allowedShareTypes.includes(type as ShareType) ? (type as ShareType) : null;
}
export namespace Rows_Share {
export type ActionData = {
success?: string;
error?: string;
errorCode?: import("~/utils/api/.server/RowsApi").RowApiErrorCode;
};
export type LoaderData = {
meta: MetaTagsDto;
rowData: RowsApi.GetRowData;
routes: EntitiesApi.Routes;
tenants: Tenant[];
users: UserWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const rowData = await RowsApi.get(params.id!, {
entity,
tenantId,
userId,
});
if (!rowData.rowPermissions.canUpdate) {
throw Error(t("shared.unauthorized"));
}
let tenants: Tenant[] = [];
if (tenantId) {
tenants.push((await getTenant(tenantId))!);
} else {
tenants = await adminGetAllTenants();
}
const data: LoaderData = {
meta: [{ title: `${t("shared.share")} | ${RowHelper.getTextDescription({ entity, item: rowData.item, t })} | ${process.env.APP_NAME}` }],
rowData,
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
tenants,
users: (await getUsersByTenant(tenantId)).filter((f) => f.id !== userId),
};
return Response.json(data);
};
export const action: ActionFunction = async ({ request, params }) => {
const { t, entity, tenantId, userId, form } = await RowsRequestUtils.getAction({ request, params });
const user = await getUser(userId);
if (!user) {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const action = form.get("action");
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const rowData = await RowsApi.get(params.id!, {
entity,
tenantId,
userId,
});
if (!rowData.rowPermissions.canUpdate) {
throw Error(t("shared.unauthorized"));
}
if (action === "share") {
const type = getShareType(form.get("type"));
if (!type) {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
const id = form.get("id")?.toString() ?? "";
const access = form.get("access")?.toString() as RowAccess;
try {
await RowPermissionsApi.share(rowData.item, {
type,
id,
access,
}, { currentTenantId: tenantId });
await EventsService.create({
request,
event: "row.shared",
tenantId,
userId,
data: {
id: rowData.item.id,
title: RowHelper.getTextDescription({ entity, item: rowData.item, t }),
entity: { id: entity.id, name: entity.name, slug: entity.slug, title: entity.title },
type,
to: id,
access,
user: { id: user.id, email: user.email },
} satisfies RowSharedDto,
});
return Response.json({ success: t("shared.saved") });
} catch (error: unknown) {
return rowActionError(t, error);
}
} else if (action === "set-access") {
const id = form.get("id")?.toString() ?? "";
const access = form.get("access")?.toString() as RowAccess;
await RowPermissionsApi.setAccessForRow(rowData.item.id, id, access);
return Response.json({ success: t("shared.saved") });
} else if (action === "remove") {
const id = form.get("id")?.toString() ?? "";
await RowPermissionsApi.delForRow(rowData.item.id, id);
return Response.json({ success: t("shared.deleted") });
} else {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
};
}
function rowActionError(t: TFunction, error: unknown) {
return Response.json(
{ error: translateRowsRouteError(t, error), errorCode: getRowsRouteErrorCode(error) } satisfies Rows_Share.ActionData,
{ status: getRowsRouteErrorStatus(error) }
);
}
@@ -0,0 +1,125 @@
import { EntityTag } from "@toolctrl/db/prisma-browser";
import { LoaderFunctionArgs, redirect, ActionFunction } from "react-router";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { Colors } from "~/application/enums/shared/Colors";
import { EntitiesApi } from "~/utils/api/.server/EntitiesApi";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { getEntityTags, getEntityTag, createEntityTag, updateEntityTag, deleteEntityTag, getEntityTagById } from "~/utils/db/entities/entityTags.db.server";
import { getRowTag, createRowTag, deleteRowTags } from "~/utils/db/entities/rowTags.db.server";
import RowHelper from "~/utils/helpers/RowHelper";
import RowsRequestUtils from "../utils/RowsRequestUtils";
import { CustomError } from "~/application/dtos/shared/CustomError";
export namespace Rows_Tags {
export type LoaderData = {
meta: MetaTagsDto;
rowData: RowsApi.GetRowData;
routes: EntitiesApi.Routes;
tags: EntityTag[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t, userId, tenantId, entity } = await RowsRequestUtils.getLoader({ request, params });
if (!entity.isAutogenerated || entity.type === "system") {
throw redirect(tenantId ? UrlUtils.currentTenantUrl(params, "404") : "/404");
}
const rowData = await RowsApi.get(params.id!, {
entity,
tenantId,
userId,
});
if (!rowData.rowPermissions.canUpdate) {
throw Response.json(new CustomError(t("models.row.permissionMessages.cannotUpdateRecord"), { permissions: rowData.rowPermissions }), { status: 403 });
}
const data: LoaderData = {
meta: [{ title: `${t("shared.tag")} | ${RowHelper.getTextDescription({ entity, item: rowData.item, t })} | ${process.env.APP_NAME}` }],
rowData,
tags: await getEntityTags(entity.id),
routes: EntitiesApi.getNoCodeRoutes({ request, params }),
};
return Response.json(data);
};
const badRequest = (data: { error: string }) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const { t, userId, tenantId, entity, form } = await RowsRequestUtils.getAction({ request, params });
const rowData = await RowsApi.get(params.id!, {
entity,
tenantId,
userId,
});
const action = form.get("action");
const { item } = rowData;
const canMutateTagCatalog = !tenantId;
if (!rowData.rowPermissions.canUpdate) {
throw Response.json(new CustomError(t("models.row.permissionMessages.cannotUpdateRecord"), { permissions: rowData.rowPermissions }), { status: 403 });
}
if (action === "new-tag") {
const value = form.get("tag-name")?.toString() ?? "";
const color = Number(form.get("tag-color") ?? Colors.INDIGO);
let tag = await getEntityTag(entity.id, value);
if (!tag) {
if (!canMutateTagCatalog) {
return badRequest({ error: t("shared.notFound") });
}
tag = await createEntityTag({
entityId: entity.id,
value,
color,
});
}
const existingTag = await getRowTag(item.id, value);
if (tag && !existingTag) {
await createRowTag({
rowId: item.id,
tagId: tag.id,
});
}
return Response.json({});
} else if (action === "edit-tag") {
if (!canMutateTagCatalog) {
return Response.json(new CustomError(t("shared.unauthorized")), { status: 403 });
}
const id = form.get("tag-id")?.toString() ?? "";
const value = form.get("tag-name")?.toString() ?? "";
const color = Number(form.get("tag-color"));
const tag = await getEntityTagById(id, entity.id);
if (!tag) {
return badRequest({ error: t("shared.notFound") });
}
await updateEntityTag({ id: tag.id, entityId: entity.id }, {
value,
color,
});
return Response.json({});
} else if (action === "set-tag") {
const id = form.get("tag-id")?.toString() ?? "";
const tagAction = form.get("tag-action")?.toString() ?? "";
const tag = await getEntityTagById(id, entity.id);
if (!tag) {
return badRequest({ error: t("shared.notFound") });
}
if (tagAction === "add") {
await createRowTag({
rowId: item.id,
tagId: tag.id,
});
} else {
await deleteRowTags(item.id, tag.id);
}
return Response.json({});
} else if (action === "delete-tag") {
if (!canMutateTagCatalog) {
return Response.json(new CustomError(t("shared.unauthorized")), { status: 403 });
}
const id = form.get("tag-id")?.toString() ?? "";
const tag = await getEntityTagById(id, entity.id);
if (tag) {
await deleteEntityTag({ id: tag.id, entityId: entity.id });
}
return Response.json({});
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
}
@@ -0,0 +1,32 @@
import fs from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
const routeFiles = [
"Rows_List.server.tsx",
"Rows_New.server.ts",
"Rows_Import.server.ts",
"Rows_Export.server.ts",
"Rows_Edit.server.ts",
"Rows_Overview.server.ts",
];
describe("rows route meta i18n", () => {
it("uses entity translation helpers for persisted autogenerated labels", () => {
for (const file of routeFiles) {
const source = fs.readFileSync(path.resolve(process.cwd(), "apps/web/app/modules/rows/routes", file), "utf8");
expect(source).toContain("translateEntityTitle");
expect(source).not.toContain("t(entity.titlePlural)");
expect(source).not.toContain("t(entity.title)");
}
});
it("keeps RowListFetcher slide-over titles helper-based", () => {
const source = fs.readFileSync(path.resolve(process.cwd(), "apps/web/app/modules/rows/fetchers/RowListFetcher.tsx"), "utf8");
expect(source).toContain("translateEntityTitle(t, i18n, data.rowsData.entity)");
expect(source).not.toContain("t(data?.rowsData?.entity.title");
});
});