@rebasepro/common 0.17.3 → 0.18.1

package/src/util/entities.ts

@@ -1,282 +0,0 @@
-import {
-    DataType,
-    Entity,
-    EntityReference,
-    EntityRelation,
-    EntityStatus,
-    EntityValues,
-    Properties,
-    Property
-} from "@rebasepro/types";
-import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
-import { mergeDeep } from "@rebasepro/utils";
-
-export function isPropertyBuilder(property?: Property) {
-    return typeof property?.dynamicProps === "function";
-}
-
-export function getDefaultValuesFor<M extends Record<string, unknown>>(properties: Properties): Partial<EntityValues<M>> {
-    if (!properties) return {};
-    return Object.entries(properties)
-        .map(([key, property]) => {
-            if (!property) return {};
-            const value = getDefaultValueFor(property);
-            return value === undefined ? {} : { [key]: value };
-        })
-        .reduce((a, b) => ({ ...a,
-...b }), {}) as EntityValues<M>;
-}
-
-export function getDefaultValueFor(property?: Property): unknown {
-    if (!property) return undefined;
-    if (isPropertyBuilder(property)) return undefined;
-    if (property.defaultValue || property.defaultValue === null) {
-        return property.defaultValue;
-    } else if (property.type === "map" && property.properties) {
-        const defaultValuesFor = getDefaultValuesFor(property.properties as Properties);
-        if (Object.keys(defaultValuesFor).length === 0) return undefined;
-        return defaultValuesFor;
-    } else {
-        return getDefaultValueFortype(property.type);
-    }
-}
-
-export function getDefaultValueFortype(type: DataType): unknown {
-    if (type === "string") {
-        return null;
-    } else if (type === "number") {
-        return null;
-    } else if (type === "boolean") {
-        return false;
-    } else if (type === "date") {
-        return null;
-    } else if (type === "array") {
-        return [];
-    } else if (type === "map") {
-        return {};
-    } else if (type === "vector") {
-        return null;
-    } else if (type === "binary") {
-        return null;
-    } else {
-        return null;
-    }
-}
-
-/**
- * Update the automatic values in a entity before save
- * @group Driver
- */
-export function updateDateAutoValues<M extends Record<string, unknown>>({
-    inputValues,
-    properties,
-    status,
-    timestampNowValue
-}:
-    {
-        inputValues: Partial<EntityValues<M>>,
-        properties: Properties,
-        status: EntityStatus,
-        timestampNowValue: unknown
-    }): EntityValues<M> {
-    return traverseValuesProperties(
-        inputValues,
-        properties,
-        (inputValue, property) => {
-            if (property.type === "date") {
-                if (status === "existing" && property.autoValue === "on_update") {
-                    return timestampNowValue;
-                } else if ((status === "new" || status === "copy") &&
-                    (property.autoValue === "on_update" || property.autoValue === "on_create")) {
-                    return timestampNowValue;
-                } else {
-                    return inputValue;
-                }
-            } else {
-                return inputValue;
-            }
-        }
-    ) ?? {} as M;
-}
-
-/**
- * Add missing required fields, expected in the collection, to the values of a entity
- * @param values
- * @param properties
- * @group Driver
- */
-export function sanitizeData<M extends Record<string, unknown>>
-    (
-        values: EntityValues<M>,
-        properties: Properties
-    ) {
-    const result = values as Record<string, unknown>;
-    Object.entries(properties)
-        .forEach(([key, property]) => {
-            if (values && values[key] !== undefined) result[key] = values[key];
-            else if ((property as Property).validation?.required) result[key] = null;
-        });
-    return result;
-}
-
-export function getReferenceFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityReference {
-    if (typeof entity.id !== "string")
-        throw new Error("Only string IDs are supported in references");
-    return new EntityReference({
-        id: entity.id,
-        path: entity.path,
-        driver: entity.driver,
-        databaseId: entity.databaseId
-    });
-}
-
-export function getRelationFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityRelation {
-    return new EntityRelation(entity.id, entity.path, entity as unknown as Record<string, unknown>);
-}
-
-/**
- * Normalize a value into a proper EntityRelation instance.
- * Handles EntityRelation class instances, and plain objects
- * with `__type === "relation"` or an `isEntityRelation()` method.
- *
- * When `propertyType` is `"relation"`, also accepts plain objects that
- * have `id` and `path` fields — these are relation-shaped objects from
- * edge cases in the data pipeline (REST fallback, stale cache, custom data source).
- *
- * When `targetPath` is given, also accepts a bare id. A relation column is a
- * foreign key, and the REST layer returns it as the scalar it is; only some
- * fetch paths hydrate it into an object. Which form a caller sees therefore
- * depends on how the row was loaded, and a caller that only accepted objects
- * reported half of its own data as a type error. The declared target is the
- * missing half: with it, an id is a relation that has not been fetched yet.
- *
- * Returns null if the value cannot be coerced.
- */
-export function normalizeToEntityRelation(value: unknown, propertyType?: string, targetPath?: string): EntityRelation | null {
-    if (value instanceof EntityRelation) return value;
-
-    if (targetPath && (typeof value === "string" || typeof value === "number")) {
-        // An empty string is an unset foreign key, not row "".
-        if (value === "") return null;
-        return new EntityRelation(value, targetPath);
-    }
-
-    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-
-    const obj = value as Record<string, unknown>;
-    const isRelationLike =
-        obj.__type === "relation" ||
-        obj.__type === "reference" ||
-        (typeof obj.isEntityRelation === "function" && (obj.isEntityRelation as () => boolean)()) ||
-        (typeof obj.isEntityReference === "function" && (obj.isEntityReference as () => boolean)()) ||
-        (propertyType === "relation" && typeof obj.id !== "undefined" && typeof obj.path === "string");
-
-    if (!isRelationLike) return null;
-
-    return new EntityRelation(
-        obj.id as string | number,
-        obj.path as string,
-        obj.data as Record<string, unknown> | undefined
-    );
-}
-
-export function traverseValuesProperties<M extends Record<string, unknown>>(
-    inputValues: Partial<EntityValues<M>>,
-    properties: Properties,
-    operation: (value: unknown, property: Property) => unknown
-): EntityValues<M> | undefined {
-    // Handle null/undefined inputValues - use empty object as base for mergeDeep
-    const safeInputValues = inputValues ?? {};
-
-    const updatedValues = Object.entries(properties)
-        .map(([key, property]) => {
-            const inputValue = safeInputValues && (safeInputValues)[key];
-            const updatedValue = traverseValueProperty(inputValue, property as Property, operation);
-            if (updatedValue === null) return null;
-            if (updatedValue === undefined) return undefined;
-            return ({ [key]: updatedValue });
-        })
-        .reduce((a, b) => ({ ...a,
-...b }), {}) as EntityValues<M>;
-    // Use mergeDeep to preserve class instances like EntityReference, GeoPoint
-    const result = mergeDeep(safeInputValues, updatedValues);
-    if (!result || Object.keys(result).length === 0) return undefined;
-    return result;
-}
-
-export function traverseValueProperty(inputValue: unknown,
-    property: Property,
-    operation: (value: unknown, property: Property) => unknown): unknown {
-
-    let value;
-    if (property.type === "map" && property.properties) {
-        value = traverseValuesProperties(inputValue as Partial<Record<string, unknown>>, property.properties, operation);
-    } else if (property.type === "array") {
-        const of = property.of;
-        if (of && Array.isArray(inputValue) && !Array.isArray(of)) {
-            value = inputValue.map((e) => traverseValueProperty(e, of, operation));
-        } else if (of && Array.isArray(inputValue) && Array.isArray(of)) {
-            value = inputValue.map((e, i) => {
-                if (i < of.length)
-                    return traverseValueProperty(e, of[i], operation);
-                return null
-            }).filter(Boolean);
-        } else if (property.oneOf && Array.isArray(inputValue)) {
-            const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
-            const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
-            value = inputValue.map((e) => {
-                if (e === null) return null;
-                if (typeof e !== "object") return e;
-                const rec = e as Record<string, unknown>;
-                const type = rec[typeField] as string;
-                const childProperty = property.oneOf?.properties[type];
-                if (!type || !childProperty) return e;
-                return {
-                    [typeField]: type,
-                    [valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
-                };
-            });
-        } else {
-            value = inputValue;
-        }
-    } else {
-        value = operation(inputValue, property);
-    }
-
-    return value;
-}
-
-/**
- * Relation reference types used throughout the server layer.
- * These replace the 50+ manual `{ id, path, __type: "relation" }` constructions.
- */
-export interface RelationRef {
-    readonly id: string | number;
-    readonly path: string;
-    readonly __type: "relation";
-}
-
-export interface RelationRefWithData extends RelationRef {
-    readonly data: Entity;
-}
-
-/**
- * Create a lightweight relation stub for admin views.
- * Replaces inline `{ id, path, __type: "relation" }` object literals.
- */
-export function createRelationRef(id: string | number, path: string): RelationRef {
-    return { id,
-path,
-__type: "relation" };
-}
-
-/**
- * Create a hydrated relation reference that includes the full entity data.
- * Used when entity data has been pre-fetched (e.g., via batch loading or JOINs).
- */
-export function createRelationRefWithData(id: string | number, path: string, data: Entity): RelationRefWithData {
-    return { id,
-path,
-__type: "relation",
-data };
-}

package/src/util/enums.ts

@@ -1,26 +0,0 @@
-import { EnumValueConfig, EnumValues } from "@rebasepro/types";
-
-export function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[] {
-    if (Array.isArray(enumValues)) {
-        return enumValues;
-    } else {
-        return Object.entries(enumValues).map(([id, value]) => {
-            if (typeof value === "string") {
-                return {
-                    id,
-                    label: value
-                }
-            } else {
-                return {
-                    ...value,
-                    id
-                }
-            }
-        });
-    }
-}
-
-export function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined {
-    if (key === null || key === undefined) return undefined;
-    return enumValues.find((entry) => String(entry.id) === String(key));
-}

package/src/util/identity.ts

@@ -1,202 +0,0 @@
-/**
- * Row identity: the address of a row, and how to derive it.
- *
- * Postgres has no `id`. A row is identified by its primary key — one or more
- * columns, with any names and any types. `id` is something we synthesize on top
- * of that: a single string token, because the admin needs *one* value it can put
- * in a URL (`/products/1:::2`), use as a cache key, and hang a relation ref off.
- *
- * That token is an address, not data. It is derived from the row's columns and
- * never stored in them — a row is exactly its columns, with their real types.
- * Writing the address back into the row is what used to rename primary keys
- * (`sku` → `id`) and restringify them (`42` → `"42"`) on the way out.
- *
- * These live in `common` because both sides need them and must agree exactly:
- * the driver parses an incoming address back into key columns, and the admin
- * derives the address from a row it was served.
- */
-
-/**
- * A primary-key column: its name, the type it round-trips as, and whether it is
- * a UUID (which is a string despite sometimes being described as an id "number").
- */
-export interface PrimaryKeyInfo {
-    fieldName: string;
-    type: "string" | "number";
-    isUUID?: boolean;
-}
-
-/** Separator between the parts of a composite address. */
-export const COMPOSITE_ID_SEPARATOR = ":::";
-
-/** The eight-four-four-four-twelve shape of a UUID, any version. */
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-/** Whether one address part can be a value of the column it addresses. */
-function partIsAddressable(part: string | number, pk: PrimaryKeyInfo): boolean {
-    if (pk.isUUID) return UUID_PATTERN.test(String(part));
-    if (pk.type === "number") {
-        return typeof part === "number"
-            ? Number.isFinite(part)
-            : !isNaN(parseInt(String(part), 10));
-    }
-    return true;
-}
-
-/**
- * Whether an address could name a row at all, before asking the database.
- *
- * A `uuid` column cannot hold `"new"`, and an `integer` column cannot hold
- * `"abc"` — so the answer to "which row is this" is "none", and that is a 404,
- * not a failure. Postgres cannot say so politely: the comparison never runs, it
- * raises `22P02` and aborts the enclosing transaction, after which every
- * further statement returns the far less helpful `25P02`.
- *
- * `isUUID` must come from the column, not from `isId: "uuid"` in a config: the
- * config is a claim about a key, and a `text` column that holds ids of some
- * other shape is a working app this must not start rejecting.
- */
-export function isAddressableId(idValue: string | number, primaryKeys: PrimaryKeyInfo[]): boolean {
-    if (primaryKeys.length === 0) return false;
-    if (primaryKeys.length === 1) return partIsAddressable(idValue, primaryKeys[0]);
-
-    const parts = String(idValue).split(COMPOSITE_ID_SEPARATOR);
-    if (parts.length !== primaryKeys.length) return false;
-    return parts.every((part, i) => partIsAddressable(part, primaryKeys[i]));
-}
-
-/**
- * Derive a row's address from its key columns.
- *
- * Single key → the value as a string. Composite → each part joined by
- * {@link COMPOSITE_ID_SEPARATOR}, in primary-key order, which is what
- * {@link parseIdValues} expects to invert.
- */
-export function buildCompositeId(values: Record<string, unknown>, primaryKeys: PrimaryKeyInfo[]): string {
-    if (primaryKeys.length === 0) {
-        return "";
-    }
-    if (primaryKeys.length === 1) {
-        return String(values[primaryKeys[0].fieldName] ?? "");
-    }
-    return primaryKeys.map(pk => String(values[pk.fieldName] ?? "")).join(COMPOSITE_ID_SEPARATOR);
-}
-
-/**
- * Invert {@link buildCompositeId}: turn an address back into key columns, each
- * coerced to the type its column actually round-trips as.
- *
- * This is the boundary where a URL segment becomes a query parameter, so a
- * malformed address must throw rather than silently produce a query that
- * matches the wrong row (or none).
- */
-export function parseIdValues(idValue: string | number, primaryKeys: PrimaryKeyInfo[]): Record<string, string | number> {
-    const result: Record<string, string | number> = {};
-
-    if (primaryKeys.length === 0) {
-        return result;
-    }
-
-    if (primaryKeys.length === 1) {
-        const pk = primaryKeys[0];
-        if (pk.type === "number" && !pk.isUUID) {
-            const parsed = typeof idValue === "number" ? idValue : parseInt(String(idValue), 10);
-            if (isNaN(parsed)) {
-                throw new Error(`Invalid numeric ID: ${idValue}`);
-            }
-            result[pk.fieldName] = parsed;
-        } else {
-            result[pk.fieldName] = String(idValue);
-        }
-        return result;
-    }
-
-    // Composite key
-    const parts = String(idValue).split(COMPOSITE_ID_SEPARATOR);
-    if (parts.length !== primaryKeys.length) {
-        throw new Error(`Composite ID parts mismatch. Expected ${primaryKeys.length}, got ${parts.length} for ID: ${idValue}`);
-    }
-
-    for (let i = 0; i < primaryKeys.length; i++) {
-        const pk = primaryKeys[i];
-        const val = parts[i];
-        if (pk.type === "number" && !pk.isUUID) {
-            const parsed = parseInt(val, 10);
-            if (isNaN(parsed)) {
-                throw new Error(`Invalid numeric ID component: ${val}`);
-            }
-            result[pk.fieldName] = parsed;
-        } else {
-            result[pk.fieldName] = val;
-        }
-    }
-
-    return result;
-}
-
-/**
- * The primary keys of a collection, as declared by its properties.
- *
- * This is the only tier both sides can read, because it is the only one written
- * in the config: the postgres driver can also infer keys from the Drizzle
- * schema, which the browser never sees and is never sent — the admin compiles
- * the collection files into its own bundle rather than being served them. A key
- * that lives only in the Drizzle schema is therefore invisible here, and the
- * server says so at boot (`warnOnKeysTheAdminCannotResolve`) naming the `isId`
- * to add.
- *
- * Returns an empty array when a collection declares none, which callers must
- * treat as "not addressable" rather than defaulting to `id`: guessing a key
- * that is not the real one produces confidently wrong addresses.
- */
-export function getDeclaredPrimaryKeys(collection: {
-    properties?: Record<string, unknown>;
-}): PrimaryKeyInfo[] {
-    const properties = collection.properties;
-    if (!properties) return [];
-
-    const keys: PrimaryKeyInfo[] = [];
-    for (const [fieldName, propRaw] of Object.entries(properties)) {
-        const prop = propRaw as { type?: string; isId?: unknown } | undefined;
-        if (!prop || typeof prop !== "object") continue;
-        if (!("isId" in prop) || !prop.isId) continue;
-        keys.push({
-            fieldName,
-            type: prop.type === "number" ? "number" : "string",
-            isUUID: prop.isId === "uuid"
-        });
-    }
-    return keys;
-}
-
-/**
- * The keys to address a collection's rows with, resolved the way the driver
- * resolves them — minus the tier the browser cannot reach.
- *
- * The postgres driver tries, in order: properties marked `isId`; the primary
- * keys of the Drizzle schema; and finally a column literally named `id`. Only
- * the first and last are visible in a `CollectionConfig`, which is what both
- * sides share.
- *
- * So the two agree except on a collection that declares no `isId` and whose key
- * is known only to Drizzle. There, the driver reads the real key, and this
- * either resolves nothing (reported to the console by the caller) or — if the
- * table happens to have an unrelated `id` property — resolves `id`, which is
- * the wrong key and cannot be detected from here: the addresses look right and
- * route wrong. Only the config can settle it, so the server names both cases
- * at boot (`warnOnKeysTheAdminCannotResolve`) with the `isId` to add.
- */
-export function resolvePrimaryKeys(collection: {
-    properties?: Record<string, unknown>;
-}): PrimaryKeyInfo[] {
-    const declared = getDeclaredPrimaryKeys(collection);
-    if (declared.length > 0) return declared;
-
-    const idProp = collection.properties?.id as { type?: string } | undefined;
-    if (idProp && typeof idProp === "object") {
-        return [{ fieldName: "id",
-type: idProp.type === "number" ? "number" : "string" }];
-    }
-
-    return [];
-}

package/src/util/index.ts

@@ -1,21 +0,0 @@
-export * from "./collections";
-export * from "./common";
-export * from "./entities";
-export * from "./identity";
-export * from "./email";
-export * from "./enums";
-export * from "./paths";
-export * from "./resolutions";
-export * from "./policy";
-export * from "./permissions";
-export * from "./builders";
-export * from "./storage";
-export * from "./callbacks";
-export * from "./relations";
-export * from "./resolve-relation";
-export * from "./auth-default-policies";
-export * from "./junction-policies";
-export * from "./conditions";
-export * from "./pg-column-to-property";
-export * from "./string-column-length";
-export * from "./internal-tables";