95 lines
3.0 KiB
TypeScript
95 lines
3.0 KiB
TypeScript
import { is } from "drizzle-orm";
|
|
import { type AnyPgTable, PgTable } from "drizzle-orm/pg-core";
|
|
import { z } from "zod";
|
|
import { type ModuleId, moduleIdSchema } from "./identifiers.js";
|
|
|
|
export const POSTGRES_IDENTIFIER_MAX_LENGTH = 63;
|
|
|
|
export const moduleTableLocalNameSchema = z
|
|
.string()
|
|
.min(1)
|
|
.regex(/^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/u, "Must be a lowercase snake-case table name.");
|
|
|
|
export const physicalModuleTableNameSchema = moduleTableLocalNameSchema.max(
|
|
POSTGRES_IDENTIFIER_MAX_LENGTH,
|
|
`Must not exceed ${POSTGRES_IDENTIFIER_MAX_LENGTH} characters.`,
|
|
);
|
|
|
|
export interface ModuleSchemaDefinition<
|
|
Tables extends Readonly<Record<string, AnyPgTable>> = Readonly<Record<string, AnyPgTable>>,
|
|
> {
|
|
readonly moduleId: ModuleId;
|
|
readonly tables: Tables;
|
|
}
|
|
|
|
const schemaDefinitionKeys = new Set(["moduleId", "tables"]);
|
|
const drizzleTableIsAlias = Symbol.for("drizzle:IsAlias");
|
|
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
function hasOnlyStringKeys(value: object, allowedKeys?: ReadonlySet<string>): boolean {
|
|
return Reflect.ownKeys(value).every(
|
|
(key) => typeof key === "string" && (!allowedKeys || allowedKeys.has(key)),
|
|
);
|
|
}
|
|
|
|
export function moduleTableNamespace(moduleId: ModuleId): string {
|
|
return moduleIdSchema.parse(moduleId).replaceAll("-", "_");
|
|
}
|
|
|
|
export function moduleTablePrefix(moduleId: ModuleId): string {
|
|
return `${moduleTableNamespace(moduleId)}_`;
|
|
}
|
|
|
|
export function moduleTableName(moduleId: ModuleId, localName: string): string {
|
|
const parsedLocalName = moduleTableLocalNameSchema.parse(localName);
|
|
const tableName = `${moduleTablePrefix(moduleId)}${parsedLocalName}`;
|
|
if (!physicalModuleTableNameSchema.safeParse(tableName).success) {
|
|
throw new RangeError("The namespaced PostgreSQL table name is invalid or too long.");
|
|
}
|
|
return tableName;
|
|
}
|
|
|
|
export function isModuleSchemaDefinition(value: unknown): value is ModuleSchemaDefinition {
|
|
try {
|
|
if (
|
|
!isRecord(value) ||
|
|
!hasOnlyStringKeys(value, schemaDefinitionKeys) ||
|
|
!moduleIdSchema.safeParse(value.moduleId).success ||
|
|
!isRecord(value.tables) ||
|
|
!hasOnlyStringKeys(value.tables)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
const tables = Object.values(value.tables);
|
|
return (
|
|
tables.length > 0 &&
|
|
tables.every(
|
|
(table) =>
|
|
is(table, PgTable) &&
|
|
(table as unknown as Record<PropertyKey, unknown>)[drizzleTableIsAlias] === false,
|
|
)
|
|
);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export function parseModuleSchemaDefinition(value: unknown): ModuleSchemaDefinition {
|
|
if (!isModuleSchemaDefinition(value)) {
|
|
throw new TypeError("Invalid Ekklesia module schema definition.");
|
|
}
|
|
|
|
const tables = Object.freeze(
|
|
Object.fromEntries(
|
|
Object.entries(value.tables).sort(([left], [right]) =>
|
|
left < right ? -1 : left > right ? 1 : 0,
|
|
),
|
|
) as Record<string, AnyPgTable>,
|
|
);
|
|
return Object.freeze({ moduleId: value.moduleId, tables });
|
|
}
|