@rebasepro/utils 0.17.3 → 0.18.1

package/src/policy-names.ts

@@ -1,65 +0,0 @@
-import type { SecurityOperation, SecurityRule } from "@rebasepro/types";
-import { sha1Hex } from "./sha1";
-
-/**
- * Naming of the Postgres policies generated from a collection's security rules.
- *
- * A rule without an explicit `name` is compiled to `<table>_<op>_<hash>`, where
- * the hash covers the rule's semantics. The Studio needs the same names to tell
- * "this policy came from your code" apart from "someone wrote this in SQL" —
- * without them it treats generated policies as foreign and offers to import
- * them back into the codebase they came from.
- *
- * This is the single definition of that naming. The DDL and Drizzle generators
- * both derive names from here, so a change cannot silently rename every policy
- * in every deployed database while the UI keeps matching the old ones.
- */
-
-/** Stable digest of the parts of a rule that determine what the policy does. */
-export function getPolicyNameHash(rule: SecurityRule): string {
-    const data = JSON.stringify({
-        a: rule.access,
-        m: rule.mode,
-        op: rule.operation,
-        ops: rule.operations?.slice().sort(),
-        own: rule.ownerField,
-        rol: rule.roles?.slice().sort(),
-        pg: rule.pgRoles?.slice().sort(),
-        u: rule.using,
-        w: rule.withCheck,
-        c: rule.condition,
-        ch: rule.check
-    });
-    return sha1Hex(data).substring(0, 7);
-}
-
-/** The operations a rule expands to — `operations` wins over `operation`. */
-export function getPolicyOperations(rule: SecurityRule): readonly SecurityOperation[] {
-    return rule.operations && rule.operations.length > 0
-        ? rule.operations
-        : [rule.operation ?? "all"];
-}
-
-/**
- * Every Postgres policy name a single rule compiles to — one per operation.
- *
- * @param rule      The security rule as written in the collection config.
- * @param tableName The rule's table (see `getTableName` in `@rebasepro/common`).
- */
-export function getPolicyNamesForRule(rule: SecurityRule, tableName: string): string[] {
-    const ops = getPolicyOperations(rule);
-    const ruleHash = getPolicyNameHash(rule);
-
-    return ops.map((op, opIdx) => rule.name
-        ? (ops.length > 1 ? `${rule.name}_${op}` : rule.name)
-        : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`);
-}
-
-/** Every policy name a set of rules compiles to, for membership checks. */
-export function getPolicyNamesForRules(rules: SecurityRule[], tableName: string): Set<string> {
-    const names = new Set<string>();
-    for (const rule of rules) {
-        for (const name of getPolicyNamesForRule(rule, tableName)) names.add(name);
-    }
-    return names;
-}

package/src/regexp.ts

@@ -1,41 +0,0 @@
-export function serializeRegExp(input: RegExp): string {
-    if (!input) return "";
-    // const fragments = input.toString().match(/\/(.*?)\/([a-z]*)?$/i);
-    // if (fragments) {
-    //     if (fragments[2])
-    //         return input.toString();
-    //     return fragments[1];
-    // }
-    return input.toString();
-}
-
-/**
- * Get a RegExp out of a serialized string
- * @param input
- */
-export function hydrateRegExp(input?: string): RegExp | undefined {
-    if (!input) return undefined;
-    const fragments = input.match(/\/(.*?)\/([a-z]*)?$/i);
-    if (fragments) {
-        return new RegExp(fragments[1], fragments[2] || "");
-    } else {
-        return new RegExp(input, "");
-    }
-}
-
-/**
- * Is `input` something {@link hydrateRegExp} can turn into a working RegExp?
- *
- * This used to pattern-match the *shape* of a regex literal and, failing that,
- * fall back to "does it contain any regex-ish character" — which said yes to
- * malformed input like `/[a-z/g`. The only answer that matters to a caller is
- * whether hydration succeeds, so ask the engine instead of approximating it.
- */
-export function isValidRegExp(input: string): boolean {
-    if (!input) return false;
-    try {
-        return hydrateRegExp(input) !== undefined;
-    } catch {
-        return false;
-    }
-}

package/src/sha1.ts

@@ -1,98 +0,0 @@
-/**
- * Minimal SHA-1 implementation that runs in both Node and the browser.
- *
- * This exists because generated Postgres policy names embed a SHA-1 digest of
- * the security rule. The DDL generator runs on the server (where `node:crypto`
- * is available) but the Studio has to derive the same names in the browser to
- * tell a policy it generated apart from one it did not. `node:crypto` cannot be
- * bundled for the browser, so the shared derivation needs a portable digest.
- *
- * SHA-1 is used purely to name things deterministically — never for security.
- * The output is byte-identical to `createHash("sha1").update(str).digest("hex")`,
- * which `sha1.test.ts` pins against `node:crypto` directly.
- */
-
-/** Rotate a 32-bit word left by `n` bits. */
-function rotl(value: number, n: number): number {
-    return (value << n) | (value >>> (32 - n));
-}
-
-/**
- * SHA-1 digest of a string, hex-encoded.
- *
- * The input is encoded as UTF-8, matching Node's default handling of strings
- * passed to `hash.update(str)`.
- */
-export function sha1Hex(input: string): string {
-    const bytes: number[] = Array.from(new TextEncoder().encode(input));
-    const bitLength = bytes.length * 8;
-
-    // Padding: 0x80, then zeroes up to 56 bytes mod 64, then the length as a
-    // 64-bit big-endian integer.
-    bytes.push(0x80);
-    while (bytes.length % 64 !== 56) bytes.push(0);
-
-    const hi = Math.floor(bitLength / 0x100000000);
-    const lo = bitLength >>> 0;
-    bytes.push((hi >>> 24) & 0xff, (hi >>> 16) & 0xff, (hi >>> 8) & 0xff, hi & 0xff);
-    bytes.push((lo >>> 24) & 0xff, (lo >>> 16) & 0xff, (lo >>> 8) & 0xff, lo & 0xff);
-
-    let h0 = 0x67452301;
-    let h1 = 0xefcdab89;
-    let h2 = 0x98badcfe;
-    let h3 = 0x10325476;
-    let h4 = 0xc3d2e1f0;
-
-    const w = new Array<number>(80);
-
-    for (let offset = 0; offset < bytes.length; offset += 64) {
-        for (let i = 0; i < 16; i++) {
-            const j = offset + i * 4;
-            w[i] = ((bytes[j] << 24) | (bytes[j + 1] << 16) | (bytes[j + 2] << 8) | bytes[j + 3]) | 0;
-        }
-        for (let i = 16; i < 80; i++) {
-            w[i] = rotl(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
-        }
-
-        let a = h0;
-        let b = h1;
-        let c = h2;
-        let d = h3;
-        let e = h4;
-
-        for (let i = 0; i < 80; i++) {
-            let f: number;
-            let k: number;
-            if (i < 20) {
-                f = (b & c) | (~b & d);
-                k = 0x5a827999;
-            } else if (i < 40) {
-                f = b ^ c ^ d;
-                k = 0x6ed9eba1;
-            } else if (i < 60) {
-                f = (b & c) | (b & d) | (c & d);
-                k = 0x8f1bbcdc;
-            } else {
-                f = b ^ c ^ d;
-                k = 0xca62c1d6;
-            }
-
-            const temp = (rotl(a, 5) + f + e + k + w[i]) | 0;
-            e = d;
-            d = c;
-            c = rotl(b, 30);
-            b = a;
-            a = temp;
-        }
-
-        h0 = (h0 + a) | 0;
-        h1 = (h1 + b) | 0;
-        h2 = (h2 + c) | 0;
-        h3 = (h3 + d) | 0;
-        h4 = (h4 + e) | 0;
-    }
-
-    return [h0, h1, h2, h3, h4]
-        .map(word => (word >>> 0).toString(16).padStart(8, "0"))
-        .join("");
-}

package/src/storage.ts

@@ -1,148 +0,0 @@
-/**
- * Reading and writing the small amounts of JSON a UI keeps between sessions —
- * open tabs, column widths, collapsed groups, recent searches.
- *
- * Every one of those reads is a read of *aged* state: it was written by whatever
- * version of the app the user last ran, and it is parsed by this one. The same
- * class the database upgrade path is careful about, in a place nothing migrates.
- *
- * A hand-rolled `JSON.parse(localStorage.getItem(key)!)` has four ways to throw
- * and no way to recover from any of them:
- *
- *  - `localStorage` itself throws on access when storage is disabled (Safari
- *    private browsing, blocked third-party cookies) or absent (SSR, Node).
- *  - the stored text is not JSON, because a write was interrupted or a user
- *    edited it.
- *  - the stored text is valid JSON of the *wrong shape*, because an older
- *    release wrote an object where this one expects an array. `parsed.map` is
- *    then not a function.
- *  - `setItem` throws `QuotaExceededError` once the origin's few megabytes are
- *    full, which a view that persists query text on every edit will reach.
- *
- * When any of those happens inside a `useState` initializer it throws during
- * render, and the bad value is still there on reload, so the view is bricked
- * until someone opens devtools. These helpers turn all four into the fallback.
- */
-
-export interface WebStorageLike {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-    removeItem(key: string): void;
-}
-
-/**
- * The ambient `localStorage`, or `null` where there is not one. Access itself
- * is what throws when storage is disabled, so even reaching for it is guarded.
- */
-export function getWebStorage(): WebStorageLike | null {
-    try {
-        const storage = (globalThis as { localStorage?: WebStorageLike }).localStorage;
-        return storage ?? null;
-    } catch {
-        return null;
-    }
-}
-
-export type ReadStoredJsonOptions<T> = {
-    /** Returned whenever the stored value is missing, unreadable or rejected. */
-    fallback: T;
-    /**
-     * Whether the parsed value is the shape this caller expects. Pass it
-     * whenever the fallback is an array or a keyed object: valid JSON of the
-     * wrong shape is the failure an upgrade actually produces, and it survives
-     * `JSON.parse` untouched to fail later at the first `.map` or `.find`.
-     */
-    accept?: (value: unknown) => boolean;
-    /** Defaults to the ambient `localStorage`. */
-    storage?: WebStorageLike | null;
-};
-
-/**
- * Reads and parses a JSON value a previous session stored, falling back rather
- * than throwing. See the module comment for what it is falling back from.
- *
- * A rejected value is deliberately left in place rather than cleared: this
- * version not understanding it is not evidence that nothing does.
- */
-export function readStoredJson<T>(key: string, options: ReadStoredJsonOptions<T>): T {
-    const storage = options.storage === undefined ? getWebStorage() : options.storage;
-    if (!storage) return options.fallback;
-
-    let raw: string | null;
-    try {
-        raw = storage.getItem(key);
-    } catch {
-        return options.fallback;
-    }
-    if (raw === null || raw === "") return options.fallback;
-
-    let parsed: unknown;
-    try {
-        parsed = JSON.parse(raw);
-    } catch {
-        return options.fallback;
-    }
-
-    if (options.accept && !options.accept(parsed)) return options.fallback;
-    return parsed as T;
-}
-
-/**
- * Persists a value as JSON. Returns whether it was stored, so a caller that
- * cares can say so — most do not, and for them the point is simply that a full
- * quota does not throw out of the effect doing the writing.
- */
-export function writeStoredJson(
-    key: string,
-    value: unknown,
-    options: { storage?: WebStorageLike | null } = {}
-): boolean {
-    const storage = options.storage === undefined ? getWebStorage() : options.storage;
-    if (!storage) return false;
-    try {
-        storage.setItem(key, JSON.stringify(value));
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Persists an already-serialised string, for the values kept as plain text
- * rather than JSON — a selected id, a pane size.
- */
-export function writeStoredString(
-    key: string,
-    value: string,
-    options: { storage?: WebStorageLike | null } = {}
-): boolean {
-    const storage = options.storage === undefined ? getWebStorage() : options.storage;
-    if (!storage) return false;
-    try {
-        storage.setItem(key, value);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/** Reads a plain string, absent rather than throwing where there is no storage. */
-export function readStoredString(
-    key: string,
-    options: { storage?: WebStorageLike | null } = {}
-): string | null {
-    const storage = options.storage === undefined ? getWebStorage() : options.storage;
-    if (!storage) return null;
-    try {
-        return storage.getItem(key);
-    } catch {
-        return null;
-    }
-}
-
-/** `accept` for a caller whose fallback is an array. */
-export const isArrayValue = (value: unknown): boolean => Array.isArray(value);
-
-/** `accept` for a caller whose fallback is a keyed object — and not an array. */
-export const isRecordValue = (value: unknown): boolean =>
-    typeof value === "object" && value !== null && !Array.isArray(value);

package/src/strings.ts

@@ -1,117 +0,0 @@
-const tokenizeRegex = /[A-Z]{2,}(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|[0-9]+(?:[a-z](?![a-z]))?|[A-Z]/g;
-
-export const toKebabCase = (str?: string) => {
-    if (!str || typeof str !== "string") return "";
-    const regExpMatchArray = str.match(tokenizeRegex);
-    if (!regExpMatchArray) return "";
-    return regExpMatchArray
-        .map(x => x.toLowerCase())
-        .join("-");
-};
-
-const snakeCaseRegex = tokenizeRegex;
-
-export const toSnakeCase = (str?: string) => {
-    if (!str || typeof str !== "string") return "";
-    const regExpMatchArray = str.match(snakeCaseRegex);
-    if (!regExpMatchArray) return "";
-    return regExpMatchArray
-        .map(x => x.toLowerCase())
-        .join("_");
-};
-
-export function camelCase(str: string): string {
-    if (!str) return "";
-    if (str.length === 1) return str.toLowerCase();
-
-    // Split by hyphens, underscores, or spaces and filter out empty strings
-    const parts = str.split(/[-_ ]+/).filter(Boolean);
-
-    if (parts.length === 0) return "";
-
-    // Start with first part in lowercase
-    return parts[0].toLowerCase() +
-        // Transform remaining parts to have first letter uppercase
-        parts.slice(1)
-            .map(part => part.charAt(0).toUpperCase() + part.substring(1).toLowerCase())
-            .join("");
-}
-
-/**
- * A random base-36 string of exactly `strLength` characters.
- *
- * Not `Math.random().toString(36).slice(2, 2 + strLength)`: that has no
- * guaranteed length. Base-36 of a double drops trailing zeros, so the source
- * string is short about once in 36 calls and the slice quietly returns fewer
- * characters than asked for — `randomString(10)` returning 9. These values
- * prefix uploaded filenames to keep them apart, so a short one is a likelier
- * collision, and it fails at the rate that makes a test look flaky.
- */
-export function randomString(strLength = 5) {
-    const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
-    let result = "";
-    for (let i = 0; i < strLength; i++) {
-        result += alphabet.charAt(Math.floor(Math.random() * alphabet.length));
-    }
-    return result;
-}
-
-export function randomColor() {
-    return Math.floor(Math.random() * 16777215).toString(16);
-}
-
-export function slugify(text?: string, separator = "_", lowercase = true) {
-    if (!text) return "";
-    const from = "ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-"
-    const to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;
-
-    for (let i = 0, l = from.length; i < l; i++) {
-        text = text.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
-    }
-
-    text = text
-        .toString() // Cast to string
-        .trim() // Remove whitespace from both sides of a string
-        .replace(/^\s+|\s+$/g, "")
-        .replace(/\s+/g, separator) // Replace spaces with separator
-        .replace(/&/g, separator) // Replace & with separator
-        .replace(/[^\w\\-]+/g, "") // Remove all non-word chars
-        .replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"),
-            separator); // Replace multiple separators with single one
-
-    return lowercase
-        ? text.toLowerCase() // Convert the string to lowercase letters
-        : text;
-}
-
-export function unslugify(slug?: string): string {
-    if (!slug) return "";
-    if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
-        const result = slug.replace(/[-_]/g, " ");
-        return result.replace(/\w\S*/g, function (txt) {
-            return txt.charAt(0).toUpperCase() + txt.substring(1);
-        }).trim();
-    } else {
-        return slug.trim();
-    }
-}
-
-export function prettifyIdentifier(input: string) {
-    if (!input) return "";
-
-    let text = input;
-
-    // 1. Handle camelCase and Acronyms
-    // Group 1 ($1 $2): Lowercase followed by Uppercase (e.g., imageURL -> image URL)
-    // Group 2 ($3 $4): Uppercase followed by Uppercase+lowercase (e.g., XMLParser -> XML Parser)
-    text = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3 $2$4");
-
-    // 2. Replace hyphens/underscores with spaces
-    text = text.replace(/[_-]+/g, " ");
-
-    // 3. Capitalize first letter of each word (Title Case)
-    const s = text
-        .trim()
-        .replace(/\b\w/g, (char) => char.toUpperCase());
-    return s;
-}