@rebasepro/common 0.1.0 → 0.2.1

package/src/util/relations.d.ts

@@ -0,0 +1,22 @@
+import { EntityCollection, Property, Relation } from "@rebasepro/types";
+export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation;
+export declare function resolveCollectionRelations(collection: EntityCollection): Record<string, Relation>;
+export declare function resolvePropertyRelation({ propertyKey, property, sourceCollection }: {
+    propertyKey: string;
+    property: Property;
+    sourceCollection: EntityCollection;
+}): Relation | undefined;
+export declare function getTableName(collection: EntityCollection): string;
+export declare function getTableVarName(tableName: string): string;
+export declare function getEnumVarName(tableName: string, propName: string): string;
+export declare function getColumnName(fullColumn: string): string;
+/**
+ * Look up a relation by key with forgiving normalization.
+ *
+ * `resolveCollectionRelations` stores each relation under a single canonical
+ * key (no aliases). This helper tries the given key as-is, then falls back to
+ * slug form (underscores → hyphens) and snake_case form (hyphens → underscores)
+ * so that callers that receive a key from external input (URL path segments,
+ * user-provided config, etc.) can still find the right entry.
+ */
+export declare function findRelation(resolvedRelations: Record<string, Relation>, key: string): Relation | undefined;

package/src/util/relations.ts

@@ -2,14 +2,58 @@ import { CollectionWithRelations, EntityCollection, getDataSourceCapabilities, P
 import { toSnakeCase } from "@rebasepro/utils";
 import { generateForeignKeyName } from "@rebasepro/utils";
 
-export function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation {
+export function sanitizeRelation(
+    relation: Partial<Relation>,
+    sourceCollection: EntityCollection,
+    resolveCollection?: (slugOrTable: string) => EntityCollection | undefined
+): Relation {
     if (!relation.target) {
         throw new Error("Relation is missing a `target` collection.");
     }
-    const targetCollection = relation.target();
+
+    const rawTarget = relation.target;
+    let targetCollection: EntityCollection | undefined;
+
+    if (typeof rawTarget === "string") {
+        if (resolveCollection) {
+            targetCollection = resolveCollection(rawTarget);
+        }
+        if (!targetCollection) {
+            targetCollection = { slug: rawTarget, name: rawTarget } as EntityCollection;
+        }
+    } else if (typeof rawTarget === "function") {
+        const evaluated = rawTarget();
+        if (typeof evaluated === "string") {
+            if (resolveCollection) {
+                targetCollection = resolveCollection(evaluated);
+            }
+            if (!targetCollection) {
+                targetCollection = { slug: evaluated, name: evaluated } as EntityCollection;
+            }
+        } else {
+            targetCollection = evaluated;
+        }
+    }
+
+    if (!targetCollection) {
+        throw new Error("Relation is missing a valid `target` collection.");
+    }
 
     const newRelation: Partial<Relation> = { ...relation };
 
+    newRelation.target = () => {
+        if (typeof rawTarget === "string") {
+            return (resolveCollection && resolveCollection(rawTarget)) || targetCollection!;
+        } else if (typeof rawTarget === "function") {
+            const evaluated = rawTarget();
+            if (typeof evaluated === "string") {
+                return (resolveCollection && resolveCollection(evaluated)) || targetCollection!;
+            }
+            return evaluated;
+        }
+        return targetCollection!;
+    };
+
     // 1. Default relationName from target collection slug
     if (!newRelation.relationName) {
         newRelation.relationName = toSnakeCase(targetCollection.slug);
@@ -41,7 +85,7 @@ export function sanitizeRelation(relation: Partial<Relation>, sourceCollection:
 
                 try {
                     // Look for an owning relation on the target that points back to this collection
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as any).relations) || []) : [];
+                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as CollectionWithRelations).relations) || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.direction === "owning" &&
                             targetRel.cardinality === "one" &&
@@ -85,16 +129,33 @@ export function sanitizeRelation(relation: Partial<Relation>, sourceCollection:
                     // Note: we intentionally do NOT require `through` here because the raw (unsanitized)
                     // relations won't have `through` populated yet — sanitizeRelation fills it in later.
                     // `cardinality: "many" + direction: "owning"` is sufficient to identify owning M2M.
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as any).relations) || []) : [];
+
+                    // 1. Check the explicit relations[] array
+                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as CollectionWithRelations).relations) || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.cardinality === "many" &&
                             (targetRel.direction === "owning" || !targetRel.direction) &&
                             (targetRel.relationName === newRelation.inverseRelationName)) {
-                            // Found a corresponding owning many-to-many relation
                             isManyToManyInverse = true;
                             break;
                         }
                     }
+
+                    // 2. Also check the target's properties for inline relation definitions
+                    //    (e.g. posts.properties.tags = { type: "relation", cardinality: "many", direction: "owning" })
+                    if (!isManyToManyInverse && targetCollection.properties) {
+                        for (const [propKey, prop] of Object.entries(targetCollection.properties)) {
+                            if ((prop as Property).type !== "relation") continue;
+                            const relProp = prop as RelationProperty;
+                            const relName = relProp.relationName || propKey;
+                            if (relName === newRelation.inverseRelationName &&
+                                relProp.cardinality === "many" &&
+                                (relProp.direction === "owning" || !relProp.direction)) {
+                                isManyToManyInverse = true;
+                                break;
+                            }
+                        }
+                    }
                 } catch (e) {
                     // If we can't inspect the target collection, assume one-to-many
                 }
@@ -152,8 +213,8 @@ export function resolveCollectionRelations(
 
     // 1. Process explicit relations from the `relations` field.
     //    Each relation is stored once under its canonical relationName key.
-    if ((relCollection as any).relations) {
-        (relCollection as any).relations.forEach((relation: Relation) => {
+    if (relCollection.relations) {
+        relCollection.relations.forEach((relation: Relation) => {
             const normalizedRelation = sanitizeRelation(relation, collection);
             const relationKey = normalizedRelation.relationName;
             if (relationKey) {
@@ -232,7 +293,7 @@ export function resolvePropertyRelation({
     }
 
     // 2. Fall back to lookup from collection.relations[] (backward compat)
-    const relation = (((sourceCollection as any).relations) ?? []).find((rel: Relation) => rel.relationName === relProp.relationName)
+    const relation = (((sourceCollection as CollectionWithRelations).relations) ?? []).find((rel: Relation) => rel.relationName === relProp.relationName)
     if (!relation) {
         console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
         return undefined;

package/src/util/resolutions.d.ts

@@ -0,0 +1,72 @@
+import { ArrayProperty, AuthController, EntityCollection, EnumValueConfig, EnumValues, NumberProperty, Properties, Property, Relation, RelationProperty, StringProperty } from "@rebasepro/types";
+type PropertyConfig = {
+    property: unknown;
+    [key: string]: unknown;
+};
+/**
+ * Resolve property builders, enums and arrays.
+ */
+export type ResolvePropertyProps<M extends Record<string, unknown> = Record<string, unknown>> = {
+    property: Property;
+    propertyKey?: string;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+};
+export declare function resolveProperty<M extends Record<string, unknown> = Record<string, unknown>>(props: ResolvePropertyProps<M>): Property | null;
+export declare function resolveRelationProperty(property: RelationProperty, relations: Relation[], propertyKey?: string): RelationProperty;
+/**
+ * Resolve enum aliases for a string or number property
+ * @param property
+ */
+export declare function resolvePropertyEnum(property: StringProperty | NumberProperty): StringProperty | NumberProperty;
+/**
+ * Resolve enums and arrays for properties
+ * @param properties
+ * @param value
+ */
+export declare function resolveProperties<M extends Record<string, unknown>>({ propertyKey, properties, ignoreMissingFields, ...props }: {
+    propertyKey?: string;
+    properties: Properties;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}): Properties;
+export declare function resolveArrayProperties<M>({ propertyKey, property, ignoreMissingFields, ...props }: {
+    propertyKey?: string;
+    property: ArrayProperty;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}): Property[];
+export declare function getArrayResolvedProperties({ propertyKey, propertyValue, property, ...props }: {
+    propertyValue: unknown;
+    propertyKey?: string;
+    property: ArrayProperty;
+    ignoreMissingFields: boolean;
+    values?: object;
+    previousValues?: object;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    authController: AuthController;
+}): Property[];
+export declare function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined;
+export declare function getSubcollections<M extends Record<string, unknown> = Record<string, unknown>>(collection: EntityCollection<M>): EntityCollection<Record<string, unknown>>[];
+export {};

package/src/util/resolutions.ts

@@ -350,8 +350,8 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
         return (collection as CollectionWithSubcollections).subcollections!() ?? [];
     }
 
-    if (getDataSourceCapabilities(collection.driver).supportsRelations && ((collection as any).relations)) {
-        const manyRelations = ((collection as any).relations)!.filter((r: Relation) => r.cardinality === "many");
+    if (getDataSourceCapabilities(collection.driver).supportsRelations && ((collection as CollectionWithRelations).relations)) {
+        const manyRelations = ((collection as CollectionWithRelations).relations)!.filter((r: Relation) => r.cardinality === "many");
         return manyRelations.map((r: Relation) => {
             const target = r.target();
             if (!target) return undefined;
@@ -376,7 +376,7 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
 
             const targetWithOverrides = { ...target, ...baseOverrides };
             return (r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides) as EntityCollection<Record<string, unknown>>;
-        }).filter((c: any): c is EntityCollection<Record<string, unknown>> => Boolean(c));
+        }).filter((c: EntityCollection<Record<string, unknown>> | undefined): c is EntityCollection<Record<string, unknown>> => Boolean(c));
     }
 
     return [];

package/src/util/storage.d.ts

@@ -0,0 +1,24 @@
+import { ArrayProperty, EntityValues, StorageConfig, StringProperty, UploadedFileContext } from "@rebasepro/types";
+interface ResolveFilenameStringParams<M extends Record<string, unknown>> {
+    input: string | ((context: UploadedFileContext) => (Promise<string> | string));
+    storage: StorageConfig;
+    values: EntityValues<M>;
+    entityId?: string | number;
+    path?: string;
+    property: StringProperty | ArrayProperty;
+    file: File;
+    propertyKey: string;
+}
+export declare function resolveStorageFilenameString<M extends Record<string, unknown>>({ input, storage, values, entityId, path, property, file, propertyKey }: ResolveFilenameStringParams<M>): Promise<string>;
+interface ResolveStoragePathStringParams<M extends Record<string, unknown>> {
+    input: string | ((context: UploadedFileContext) => string);
+    storage: StorageConfig;
+    values: EntityValues<M>;
+    entityId?: string | number;
+    path?: string;
+    property: StringProperty | ArrayProperty;
+    file: File;
+    propertyKey: string;
+}
+export declare function resolveStoragePathString<M extends Record<string, unknown>>({ input, storage, values, entityId, path, property, file, propertyKey }: ResolveStoragePathStringParams<M>): string;
+export {};