@rebasepro/common 0.7.0 → 0.8.0

package/src/util/policy/sqlToPolicy.ts

@@ -0,0 +1,88 @@
+import { PolicyExpression, policy } from "@rebasepro/types";
+
+/**
+ * A tiny, regex-based SQL "parser" for security rules.
+ *
+ * This is NOT a full SQL parser. It is designed to handle the subset of SQL
+ * commonly used in `USING` and `WITH CHECK` clauses, enough to drive the
+ * optimistic client-side UI decision.
+ *
+ * It handles:
+ * - `field = 'literal'`
+ * - `field != 'literal'`
+ * - `field = current_setting('app.user_id')`
+ * - `A AND B`
+ * - `true`
+ * - `IN (...)` (as optimistic true)
+ *
+ * For anything it doesn't understand, it returns a `raw` expression, which
+ * the evaluator treats as "unknown" (and usually optimistic true).
+ */
+export function sqlToPolicy(sql: string): PolicyExpression {
+    const trimmed = sql.trim();
+
+    if (trimmed.toLowerCase() === "true") return policy.true();
+    if (trimmed.toLowerCase() === "false") return policy.false();
+
+    // Handle roles overlap (&&)
+    // Matches: string_to_array(auth.roles(), ',') && ARRAY['admin', 'editor']
+    const overlapMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\s*\[(.+)\]$/i);
+    if (overlapMatch) {
+        const roles = overlapMatch[1].split(",").map(s => s.trim().replace(/^'|'$/g, ""));
+        return policy.rolesOverlap(roles);
+    }
+
+    // Handle roles containment (@>)
+    // Matches: string_to_array(auth.roles(), ',') @> ARRAY['admin']
+    const containMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\s*\[(.+)\]$/i);
+    if (containMatch) {
+        const roles = containMatch[1].split(",").map(s => s.trim().replace(/^'|'$/g, ""));
+        return policy.rolesContain(roles);
+    }
+
+    // Handle OR
+    if (trimmed.toUpperCase().includes(" OR ")) {
+        const parts = trimmed.split(/ OR /i);
+        return policy.or(...parts.map(sqlToPolicy));
+    }
+
+    // Handle AND (very basic split, doesn't handle nested parens properly)
+    if (trimmed.toUpperCase().includes(" AND ")) {
+        const parts = trimmed.split(/ AND /i);
+        return policy.and(...parts.map(sqlToPolicy));
+    }
+
+    // Handle = and !=
+    const match = trimmed.match(/^(.+?)\s*(!?=)\s*(.+)$/);
+    if (match) {
+        const [, leftStr, op, rightStr] = match;
+        const left = parseOperand(leftStr.trim());
+        const right = parseOperand(rightStr.trim());
+        if (left && right) {
+            return policy.compare(left, op === "=" ? "eq" : "neq", right);
+        }
+    }
+
+    // Fallback to raw
+    return policy.raw(sql);
+}
+
+function parseOperand(str: string) {
+    // current_setting('app.user_id') or auth.uid()
+    if (/current_setting\s*\(\s*'app\.user_id'\s*\)/i.test(str) || /auth\.uid\(\)/i.test(str)) {
+        return policy.authUid();
+    }
+
+    // Literal string: 'value'
+    const stringMatch = str.match(/^'(.+)'$/);
+    if (stringMatch) {
+        return policy.literal(stringMatch[1]);
+    }
+
+    // Bare field name
+    if (/^\w+$/.test(str)) {
+        return policy.field(str);
+    }
+
+    return null;
+}

package/src/util/references.ts

@@ -26,7 +26,7 @@ export function getEntityImagePreviewPropertyKey<M extends Record<string, unknow
     // and arrays of URL properties with image preview type
     for (const key in collection.properties) {
         const property = collection.properties[key];
-        if (property.type === "array" && property.of && !Array.isArray(property.of) && property.of.type === "string" && property.of.url === "image") {
+        if (property.type === "array" && property.of && !Array.isArray(property.of) && property.of.type === "string" && property.of.ui?.url === "image") {
             return key;
         }
     }

package/src/util/relations.ts

@@ -1,4 +1,4 @@
-import { CollectionWithRelations, EntityCollection, getDataSourceCapabilities, Property, Relation, RelationProperty } from "@rebasepro/types";
+import { EntityCollection, getDataSourceCapabilities, Property, Relation, RelationProperty } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 import { generateForeignKeyName } from "@rebasepro/utils";
 
@@ -89,7 +89,7 @@ name: evaluated } as EntityCollection;
 
                 try {
                     // Look for an owning relation on the target that points back to this collection
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as CollectionWithRelations).relations) || []) : [];
+                    const targetRelations = getDataSourceCapabilities(targetCollection.engine).supportsRelations ? (targetCollection.relations || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.direction === "owning" &&
                             targetRel.cardinality === "one" &&
@@ -135,7 +135,7 @@ name: evaluated } as EntityCollection;
                     // `cardinality: "many" + direction: "owning"` is sufficient to identify owning M2M.
 
                     // 1. Check the explicit relations[] array
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as CollectionWithRelations).relations) || []) : [];
+                    const targetRelations = getDataSourceCapabilities(targetCollection.engine).supportsRelations ? (targetCollection.relations || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.cardinality === "many" &&
                             (targetRel.direction === "owning" || !targetRel.direction) &&
@@ -206,8 +206,7 @@ export function resolveCollectionRelations(
     const cached = _resolvedRelationsCache.get(collection);
     if (cached) return cached;
 
-    if (!getDataSourceCapabilities(collection.driver).supportsRelations) return {};
-    const relCollection = collection as CollectionWithRelations;
+    if (!getDataSourceCapabilities(collection.engine).supportsRelations) return {};
     const relations: Record<string, Relation> = {};
 
     // Track which explicit relationName values have been registered so that
@@ -217,8 +216,8 @@ export function resolveCollectionRelations(
 
     // 1. Process explicit relations from the `relations` field.
     //    Each relation is stored once under its canonical relationName key.
-    if (relCollection.relations) {
-        relCollection.relations.forEach((relation: Relation) => {
+    if (collection.relations) {
+        collection.relations.forEach((relation: Relation) => {
             try {
                 const normalizedRelation = sanitizeRelation(relation, collection);
                 const relationKey = normalizedRelation.relationName;
@@ -306,8 +305,8 @@ export function resolvePropertyRelation({
 }
 
 export function getTableName(collection: EntityCollection): string {
-    if (getDataSourceCapabilities(collection.driver).supportsRelations) {
-        return (collection as CollectionWithRelations).table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+    if (getDataSourceCapabilities(collection.engine).supportsRelations) {
+        return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
     }
     return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 }

package/src/util/resolutions.ts

@@ -1,8 +1,6 @@
 import {
     ArrayProperty,
     AuthController,
-    CollectionWithRelations,
-    CollectionWithSubcollections,
     EntityCollection,
     EnumValueConfig,
     EnumValues,
@@ -12,7 +10,8 @@ import {
     Relation,
     RelationProperty,
     StringProperty,
-    getDataSourceCapabilities
+    getDataSourceCapabilities,
+    getDeclaredSubcollections
 } from "@rebasepro/types";
 
 type PropertyConfig = { property: unknown; [key: string]: unknown };
@@ -347,11 +346,12 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
         return collection.childCollections() ?? [];
     }
 
-    if (getDataSourceCapabilities(collection.driver).supportsSubcollections && (collection as CollectionWithSubcollections).subcollections) {
-        return (collection as CollectionWithSubcollections).subcollections!() ?? [];
+    const declaredSubcollections = getDeclaredSubcollections(collection);
+    if (getDataSourceCapabilities(collection.engine).supportsSubcollections && declaredSubcollections) {
+        return declaredSubcollections() ?? [];
     }
 
-    if (getDataSourceCapabilities(collection.driver).supportsRelations) {
+    if (getDataSourceCapabilities(collection.engine).supportsRelations) {
         const resolvedRelations = resolveCollectionRelations(collection);
         const manyRelations = Object.values(resolvedRelations).filter((r: Relation) => r.cardinality === "many");
 

package/src/util/storage.ts

@@ -1,6 +1,39 @@
-import { ArrayProperty, EntityValues, StorageConfig, StringProperty, UploadedFileContext } from "@rebasepro/types";
+import { ArrayProperty, EntityValues, StorageConfig, StorageSource, StorageSourceRegistry, StringProperty, UploadedFileContext } from "@rebasepro/types";
 import { randomString } from "@rebasepro/utils";
 
+/**
+ * Resolve the {@link StorageSource} to use for a property, given the key
+ * referenced by `StorageConfig.storageSource`.
+ *
+ * Resolution priority:
+ * 1. No `sourceKey` → the default source (backward compatible).
+ * 2. An explicit {@link StorageSourceRegistry} (e.g. `client.storageRegistry`).
+ * 3. A `sources` lookup map (e.g. the `StorageSourcesContext`).
+ * 4. Fall back to the default source.
+ *
+ * Shared by the upload hook, the markdown editor, and the read-only previews
+ * so the resolution logic lives in one place.
+ *
+ * @group Storage
+ */
+export function resolveStorageSource(params: {
+    /** Key from `StorageConfig.storageSource`. */
+    sourceKey?: string | null;
+    /** Built sources keyed by storage-source key (e.g. from context). */
+    sources?: Record<string, StorageSource>;
+    /** Optional explicit registry — takes precedence over `sources`. */
+    registry?: StorageSourceRegistry;
+    /** Default source, used when no key is set or the key cannot be resolved. */
+    defaultSource: StorageSource;
+}): StorageSource {
+    const { sourceKey, sources, registry, defaultSource } = params;
+    if (!sourceKey) return defaultSource;
+    if (registry) return registry.getOrDefault(sourceKey);
+    const fromSources = sources?.[sourceKey];
+    if (fromSources) return fromSources;
+    return defaultSource;
+}
+
 interface ResolveFilenameStringParams<M extends Record<string, unknown>> {
     input: string | ((context: UploadedFileContext) => (Promise<string> | string));
     storage: StorageConfig;