Skip to content

Open-source manufacturing ERP, MES and QMS. Quoting, MRP, inventory, shop floor, quality and lot/serial traceability on one Postgres schema, with a REST API and MCP server. Self-host or use Carbon Cloud.

11.3 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-only
// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,
// including ports, remain AGPLv3; serving them over a network requires releasing their source.

import { readdirSync } from "node:fs";
import { join } from "node:path";
import { validateEnv } from "@carbon/env/validate";
import { keyOf, loadBaseline } from "./baseline";
import type {
  ConformanceCheck,
  ModuleDir,
  SourceFile,
  StructureCheck,
  Violation
} from "./check";
import {
  DEPLOYMENTS_SET_REQUIRED_ENV,
  findDeploymentEnvGaps
} from "./conformance/deployments-set-required-env";
import {
  DOCUMENT_SEQUENCE_SYNCED,
  findUnsyncedDocumentSequences
} from "./conformance/document-sequence-synced";
import { edgeFunctionAuthorizesCaller } from "./conformance/edge-function-authorizes-caller";
import {
  EVENT_IGNORED_COLUMNS,
  findIgnoredColumnDrift
} from "./conformance/event-ignored-columns";
import {
  FUNCTION_REDEFINITION_KEEPS_CHANGES,
  findDroppedFunctionChanges
} from "./conformance/function-redefinition-keeps-changes";
import { indexRedirectBeforeLoaders } from "./conformance/index-redirect-before-loaders";
import { journalStatusFilter } from "./conformance/journal-status-filter";
import { linguiMacroMisuse } from "./conformance/lingui-macro-misuse";
import {
  findUnselectedListColumns,
  LIST_SELECT_COVERS_COLUMNS
} from "./conformance/list-select-covers-columns";
import { moduleShape } from "./conformance/module-shape";
import {
  MANAGED_FUNCTION_SETS,
  type ManagedFunction,
  noAuthzDdlInMigrations
} from "./conformance/no-authz-ddl-in-migrations";
import { noBareOutlet } from "./conformance/no-bare-outlet";
import { noDbClientInService } from "./conformance/no-db-client-in-service";
import { noDefaultOnEffects } from "./conformance/no-default-on-effects";
import { noDerivedPercentColumn } from "./conformance/no-derived-percent-column";
import {
  findDuplicatedAppFiles,
  NO_DUPLICATED_APP_FILE,
  SHARED_APP_DIRS
} from "./conformance/no-duplicated-app-file";
import { noInlineFractionDigits } from "./conformance/no-inline-fraction-digits";
import { noInlineSensorOptions } from "./conformance/no-inline-sensor-options";
import { noIntegrationIdBranching } from "./conformance/no-integration-id-branching";
import { noInterpolatedErrorLog } from "./conformance/no-interpolated-error-log";
import { noLegacyRls } from "./conformance/no-legacy-rls";
import { noLocalTimezone } from "./conformance/no-local-timezone";
import { noMissingAuditColumn } from "./conformance/no-missing-audit-column";
import { noNoopOpenChange } from "./conformance/no-noop-open-change";
import { noNumericPrecision } from "./conformance/no-numeric-precision";
import { noPostgresChanges } from "./conformance/no-postgres-changes";
import { noRawForwardedHeaders } from "./conformance/no-raw-forwarded-headers";
import { noRawOrSearch } from "./conformance/no-raw-or-search";
import { noRawRedirect } from "./conformance/no-raw-redirect";
import { noRawRevalidator } from "./conformance/no-raw-revalidator";
import { noRawRounding } from "./conformance/no-raw-rounding";
import { noRequiredColumnWithoutDefault } from "./conformance/no-required-column-without-default";
import { noServerCodeInClient } from "./conformance/no-server-code-in-client";
import { noStateCopyOfLoaderData } from "./conformance/no-state-copy-of-loader-data";
import { noUnguardedSubmit } from "./conformance/no-unguarded-submit";
import { noUnroundedTrackedQuantity } from "./conformance/no-unrounded-tracked-quantity";
import { noUnscopedKyselyWrite } from "./conformance/no-unscoped-kysely-write";
import { noViewWithoutInvoker } from "./conformance/no-view-without-invoker";
import { noZeroConcurrency } from "./conformance/no-zero-concurrency";
import {
  findProviderRoleDrift,
  PROVIDER_ROLE_BACKFILLED
} from "./conformance/provider-role-backfilled";
import { routeActionShape } from "./conformance/route-action-shape";
import {
  findScheduledSqlDrift,
  SCHEDULED_SQL_CONSTANTS
} from "./conformance/scheduled-sql-constants";
import { serviceFnFile } from "./conformance/service-fn-file";
import {
  findUndeclaredSideEffectImports,
  SIDE_EFFECT_IMPORT_DECLARED
} from "./conformance/side-effect-import-declared";
import { spdxLicenseHeader } from "./conformance/spdx-license-header";
import {
  findStampColumnMismatches,
  STAMP_MATCHES_COLUMNS
} from "./conformance/stamp-matches-columns";
import { testMocksOwnModule } from "./conformance/test-mocks-own-module";
import { testReadsSource } from "./conformance/test-reads-source";
import {
  loadDeploymentEnvSources,
  loadEventFunctionSources,
  loadIntegrationConfigs,
  loadListSources,
  loadScheduledConstantSources
} from "./sources/cross-file";
import { loadDbTableColumns } from "./sources/db-columns";
import { loadDocumentSequenceSources } from "./sources/document-sequences";
import { loadEdgeFunctions } from "./sources/edge-functions";
import { loadLicenseFiles } from "./sources/license-files";
import { loadSqlFiles, migrationsDir, repoRoot } from "./sources/migrations";
import {
  loadModuleServerFiles,
  loadModules,
  modulesDir
} from "./sources/modules";
import { loadServerFiles } from "./sources/server-files";
import { loadSideEffectPackages } from "./sources/side-effect-packages";
import { loadTestFiles } from "./sources/test-files";
import {
  loadTypescriptFiles,
  REQUEST_HANDLING_ROOTS,
  ROUTE_ROOTS
} from "./sources/typescript";

export const CONFORMANCE_CHECKS: ConformanceCheck[] = [
  noNumericPrecision,
  noLegacyRls,
  noDerivedPercentColumn,
  noRequiredColumnWithoutDefault,
  noViewWithoutInvoker,
  journalStatusFilter
];

/** Checks that run over server-side TS, not SQL migrations. */
export const SERVER_CHECKS: ConformanceCheck[] = [
  noLocalTimezone,
  noZeroConcurrency,
  routeActionShape
];

/** Checks that run over ALL app + shared-package TS (client and server). */
export const TS_CHECKS: ConformanceCheck[] = [
  noRawRounding,
  noInlineFractionDigits,
  noDbClientInService,
  noServerCodeInClient,
  serviceFnFile,
  noDefaultOnEffects,
  noUnroundedTrackedQuantity,
  noIntegrationIdBranching,
  noUnscopedKyselyWrite,
  noUnguardedSubmit,
  noNoopOpenChange,
  noPostgresChanges,
  journalStatusFilter
];

/** Checks that run over git-tracked vitest files (apps, packages, scripts, docs). */
export const TEST_CHECKS: ConformanceCheck[] = [
  testReadsSource,
  testMocksOwnModule
];

/** Checks that run once per edge function, over all of its .ts files. */
export const EDGE_FUNCTION_CHECKS: ConformanceCheck[] = [
  edgeFunctionAuthorizesCaller
];

export const STRUCTURE_CHECKS: StructureCheck[] = [moduleShape];

export type Finding = { checkId: string; violation: Violation };

export function scanAll(
  files: SourceFile[],
  checks: ConformanceCheck[] = CONFORMANCE_CHECKS
): Finding[] {
  const out: Finding[] = [];
  for (const { file, contents } of files) {
    for (const check of checks) {
      for (const violation of check.scan(file, contents)) {
        out.push({ checkId: check.id, violation });
      }
    }
  }
  return out;
}

export function scanModules(
  modules: ModuleDir[],
  checks: StructureCheck[] = STRUCTURE_CHECKS
): Finding[] {
  const out: Finding[] = [];
  for (const m of modules) {
    for (const check of checks) {
      for (const violation of check.inspect(m)) {
        out.push({ checkId: check.id, violation });
      }
    }
  }
  return out;
}

/** The managed functions: one `<name>.sql` (or `<schema>.<name>.sql`) file each. */
export function loadManagedFunctions(root: string): ManagedFunction[] {
  return MANAGED_FUNCTION_SETS.flatMap(({ dir, since }) =>
    readdirSync(join(root, dir))
      .filter((file) => file.endsWith(".sql"))
      .map((file) => {
        const [first = "", second] = file.replace(/\.sql$/, "").split(".");
        return {
          schema: second ? first : "public",
          name: second ?? first,
          file: `${dir}/${file}`,
          since
        };
      })
  );
}

/** Every finding across the real migrations (text) + modules (structure) + server TS + app TS + edge functions + license headers under `root`. */
export function collectFindings(root: string = repoRoot()): Finding[] {
  const migrations = loadSqlFiles(migrationsDir(root));
  const listSources = loadListSources(root);
  const eventSources = loadEventFunctionSources(root);
  return [
    ...scanAll(loadSqlFiles(migrationsDir(root)), [
      ...CONFORMANCE_CHECKS,
      noAuthzDdlInMigrations(loadManagedFunctions(root))
    ]),
    ...scanModules(loadModules(modulesDir(root))),
    ...scanAll(loadServerFiles(root), SERVER_CHECKS),
    // noMissingAuditColumn needs the real column list, so it is built from the
    // generated types here rather than sitting in TS_CHECKS — the same shape as
    // noAuthzDdlInMigrations above, which keeps every `scan` pure.
    ...scanAll(loadTypescriptFiles(root), [
      ...TS_CHECKS,
      noMissingAuditColumn(loadDbTableColumns(root))
    ]),
    ...scanAll(loadTypescriptFiles(root, REQUEST_HANDLING_ROOTS), [
      noRawForwardedHeaders,
      noInterpolatedErrorLog,
      noRawRedirect,
      linguiMacroMisuse
    ]),
    ...scanAll(loadTypescriptFiles(root), [
      noRawOrSearch,
      noRawRevalidator,
      noInlineSensorOptions,
      noBareOutlet,
      noStateCopyOfLoaderData
    ]),
    ...scanAll(loadTypescriptFiles(root, ROUTE_ROOTS), [
      indexRedirectBeforeLoaders
    ]),
    ...scanAll(loadEdgeFunctions(root), EDGE_FUNCTION_CHECKS),
    ...scanAll(loadLicenseFiles(root), [spdxLicenseHeader]),
    ...findDuplicatedAppFiles(loadTypescriptFiles(root, SHARED_APP_DIRS)).map(
      (violation) => ({ checkId: NO_DUPLICATED_APP_FILE, violation })
    ),
    ...findUnsyncedDocumentSequences(loadDocumentSequenceSources(root)).map(
      (violation) => ({ checkId: DOCUMENT_SEQUENCE_SYNCED, violation })
    ),
    ...findDroppedFunctionChanges(migrations).map((violation) => ({
      checkId: FUNCTION_REDEFINITION_KEEPS_CHANGES,
      violation
    })),
    ...findStampColumnMismatches(
      loadModuleServerFiles(root),
      loadDbTableColumns(root)
    ).map((violation) => ({ checkId: STAMP_MATCHES_COLUMNS, violation })),
    ...findUndeclaredSideEffectImports(loadSideEffectPackages(root)).map(
      (violation) => ({ checkId: SIDE_EFFECT_IMPORT_DECLARED, violation })
    ),
    ...scanAll(loadTestFiles(root), TEST_CHECKS),
    ...findUnselectedListColumns(listSources.services, listSources.tables).map(
      (violation) => ({ checkId: LIST_SELECT_COVERS_COLUMNS, violation })
    ),
    ...findProviderRoleDrift(loadIntegrationConfigs(root), migrations).map(
      (violation) => ({ checkId: PROVIDER_ROLE_BACKFILLED, violation })
    ),
    ...findIgnoredColumnDrift(
      eventSources.functions,
      eventSources.auditConfig
    ).map((violation) => ({ checkId: EVENT_IGNORED_COLUMNS, violation })),
    ...findScheduledSqlDrift(
      migrations,
      loadScheduledConstantSources(root)
    ).map((violation) => ({ checkId: SCHEDULED_SQL_CONSTANTS, violation })),
    ...findDeploymentEnvGaps(loadDeploymentEnvSources(root), (env) =>
      validateEnv(env)
        .problems.filter((p) => p.level === "error")
        .map((p) => p.name)
    ).map((violation) => ({ checkId: DEPLOYMENTS_SET_REQUIRED_ENV, violation }))
  ];
}

/** Findings in the real migrations/modules that are NOT grandfathered by the baseline. */
export function newViolations(): Finding[] {
  const baseline = loadBaseline();
  return collectFindings().filter(
    (f) => !baseline.has(keyOf(f.checkId, f.violation))
  );
}