supabase-strict-check 0.1.0

package/dist/lib/program.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+export declare function createBackendProgram(target: string, files: string[], typesFile: string): ts.Program;
+export declare function stringLiteralsFromType(type: ts.Type): string[] | null;
+export declare function stringFromType(checker: ts.TypeChecker, node: ts.Node): string | null;
+export declare function propertyNamesFromType(checker: ts.TypeChecker, node: ts.Node): string[] | null;
+export declare function calleeFunction(call: ts.CallExpression, checker: ts.TypeChecker): ts.FunctionLikeDeclaration | undefined;

package/dist/lib/program.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBackendProgram = createBackendProgram;
+exports.stringLiteralsFromType = stringLiteralsFromType;
+exports.stringFromType = stringFromType;
+exports.propertyNamesFromType = propertyNamesFromType;
+exports.calleeFunction = calleeFunction;
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function createBackendProgram(target, files, typesFile) {
+    const configPath = typescript_1.default.findConfigFile(target, typescript_1.default.sys.fileExists, "tsconfig.json");
+    const rootNames = [...new Set([...files, typesFile])];
+    if (!configPath) {
+        return typescript_1.default.createProgram({
+            rootNames,
+            options: {
+                noEmit: true,
+                skipLibCheck: true,
+                strict: true,
+                target: typescript_1.default.ScriptTarget.ES2022,
+                module: typescript_1.default.ModuleKind.CommonJS,
+                moduleResolution: typescript_1.default.ModuleResolutionKind.Node10,
+                esModuleInterop: true,
+            },
+        });
+    }
+    const { config, error } = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+    if (error) {
+        throw new Error(typescript_1.default.flattenDiagnosticMessageText(error.messageText, "\n"));
+    }
+    const parsed = typescript_1.default.parseJsonConfigFileContent(config, typescript_1.default.sys, node_path_1.default.dirname(configPath));
+    return typescript_1.default.createProgram({
+        rootNames: [...new Set([...parsed.fileNames, ...rootNames])],
+        options: {
+            ...parsed.options,
+            noEmit: true,
+            skipLibCheck: true,
+        },
+    });
+}
+function stringLiteralsFromType(type) {
+    if (type.isStringLiteral())
+        return [type.value];
+    if (type.isUnion()) {
+        const lits = [];
+        for (const t of type.types) {
+            if (!t.isStringLiteral())
+                return null;
+            lits.push(t.value);
+        }
+        return lits.length ? lits : null;
+    }
+    return null;
+}
+function stringFromType(checker, node) {
+    const lits = stringLiteralsFromType(checker.getTypeAtLocation(node));
+    return lits?.length === 1 ? lits[0] : null;
+}
+const OBJECT_PROTO = new Set([
+    "constructor",
+    "toString",
+    "toLocaleString",
+    "valueOf",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+]);
+function propertyNamesFromType(checker, node) {
+    const type = checker.getTypeAtLocation(node);
+    const flags = type.getFlags();
+    if (flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown | typescript_1.default.TypeFlags.Never))
+        return null;
+    if (type.getStringIndexType() && type.getProperties().length === 0)
+        return null;
+    const names = type.getProperties()
+        .map((p) => p.getName())
+        .filter((n) => n && !n.startsWith("__") && !OBJECT_PROTO.has(n));
+    return names.length ? names : null;
+}
+function calleeFunction(call, checker) {
+    const expr = call.expression;
+    const target = typescript_1.default.isPropertyAccessExpression(expr) ? expr.name : expr;
+    const symbol = checker.getSymbolAtLocation(target) ?? checker.getSymbolAtLocation(expr);
+    if (!symbol)
+        return undefined;
+    return functionFromSymbol(symbol, checker, new Set());
+}
+function functionFromSymbol(symbol, checker, seen) {
+    if (seen.has(symbol))
+        return undefined;
+    seen.add(symbol);
+    let resolved = symbol;
+    if (resolved.flags & typescript_1.default.SymbolFlags.Alias) {
+        resolved = checker.getAliasedSymbol(resolved);
+    }
+    for (const decl of resolved.getDeclarations() ?? []) {
+        if (typescript_1.default.isFunctionDeclaration(decl)
+            || typescript_1.default.isMethodDeclaration(decl)
+            || typescript_1.default.isFunctionExpression(decl)
+            || typescript_1.default.isArrowFunction(decl)) {
+            return decl;
+        }
+        if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+            const init = unwrapInit(decl.initializer);
+            if (typescript_1.default.isFunctionExpression(init) || typescript_1.default.isArrowFunction(init))
+                return init;
+        }
+        if (typescript_1.default.isShorthandPropertyAssignment(decl)) {
+            const value = checker.getShorthandAssignmentValueSymbol(decl);
+            if (value) {
+                const fn = functionFromSymbol(value, checker, seen);
+                if (fn)
+                    return fn;
+            }
+        }
+        if (typescript_1.default.isPropertyAssignment(decl)) {
+            const init = unwrapInit(decl.initializer);
+            if (typescript_1.default.isFunctionExpression(init) || typescript_1.default.isArrowFunction(init))
+                return init;
+            if (typescript_1.default.isIdentifier(init)) {
+                const value = checker.getSymbolAtLocation(init);
+                if (value) {
+                    const fn = functionFromSymbol(value, checker, seen);
+                    if (fn)
+                        return fn;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function unwrapInit(expr) {
+    let current = expr;
+    while (typescript_1.default.isParenthesizedExpression(current)
+        || typescript_1.default.isAsExpression(current)
+        || typescript_1.default.isTypeAssertionExpression(current)
+        || typescript_1.default.isSatisfiesExpression(current)
+        || typescript_1.default.isNonNullExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}

package/dist/lib/scope.d.ts

@@ -0,0 +1,12 @@
+import type { QueryBinding } from "./types";
+export declare class Scope {
+    private readonly parent?;
+    private readonly queries;
+    private readonly objects;
+    constructor(parent?: Scope | undefined);
+    child(): Scope;
+    setQuery(name: string, binding: QueryBinding): void;
+    getQuery(name: string): QueryBinding | undefined;
+    setObject(name: string, expr: import("typescript").Expression): void;
+    getObject(name: string): import("typescript").Expression | undefined;
+}

package/dist/lib/scope.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+class Scope {
+    parent;
+    queries = new Map();
+    objects = new Map();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    child() {
+        return new Scope(this);
+    }
+    setQuery(name, binding) {
+        this.queries.set(name, {
+            relation: binding.relation,
+            embeds: new Map(binding.embeds),
+        });
+    }
+    getQuery(name) {
+        return this.queries.get(name) ?? this.parent?.getQuery(name);
+    }
+    setObject(name, expr) {
+        this.objects.set(name, expr);
+    }
+    getObject(name) {
+        return this.objects.get(name) ?? this.parent?.getObject(name);
+    }
+}
+exports.Scope = Scope;

package/dist/lib/select.d.ts

@@ -0,0 +1,6 @@
+import type { SelectItem } from "./types";
+export declare function splitTopLevel(input: string, sep: string): string[];
+export declare function parseSelectList(input: string): SelectItem[];
+export declare function parseSelectItem(raw: string): SelectItem | null;
+/** Columns referenced in PostgREST `or` / `and` filter strings. */
+export declare function filterColumns(filter: string): string[];

package/dist/lib/select.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitTopLevel = splitTopLevel;
+exports.parseSelectList = parseSelectList;
+exports.parseSelectItem = parseSelectItem;
+exports.filterColumns = filterColumns;
+function splitTopLevel(input, sep) {
+    const parts = [];
+    let depth = 0;
+    let inQuote = null;
+    let start = 0;
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (inQuote) {
+            if (ch === inQuote && input[i - 1] !== "\\")
+                inQuote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            inQuote = ch;
+            continue;
+        }
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        else if (ch === sep && depth === 0) {
+            parts.push(input.slice(start, i));
+            start = i + sep.length;
+        }
+    }
+    parts.push(input.slice(start));
+    return parts;
+}
+function parseSelectList(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return [];
+    const items = [];
+    for (const part of splitTopLevel(trimmed, ",")) {
+        const item = parseSelectItem(part.trim());
+        if (item)
+            items.push(item);
+    }
+    return items;
+}
+function parseSelectItem(raw) {
+    let s = raw.trim();
+    if (!s)
+        return null;
+    let children = null;
+    if (s.endsWith(")")) {
+        let depth = 0;
+        let open = -1;
+        for (let i = s.length - 1; i >= 0; i--) {
+            if (s[i] === ")")
+                depth++;
+            else if (s[i] === "(") {
+                depth--;
+                if (depth === 0) {
+                    open = i;
+                    break;
+                }
+            }
+        }
+        if (open >= 0) {
+            children = parseSelectList(s.slice(open + 1, s.length - 1));
+            s = s.slice(0, open).trim();
+        }
+    }
+    let alias = null;
+    const colon = s.indexOf(":");
+    if (colon > 0) {
+        const maybeAlias = s.slice(0, colon).trim();
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(maybeAlias) && !maybeAlias.includes("!")) {
+            alias = maybeAlias;
+            s = s.slice(colon + 1).trim();
+        }
+    }
+    const bangParts = s.split("!").map((p) => p.trim()).filter(Boolean);
+    if (bangParts.length === 0)
+        return null;
+    let name = bangParts[0];
+    const castAt = name.indexOf("::");
+    if (castAt >= 0)
+        name = name.slice(0, castAt).trim();
+    if (name === "")
+        return null;
+    return {
+        alias,
+        name,
+        hints: bangParts.slice(1).map((h) => h.replace(/::.*$/, "")),
+        children,
+    };
+}
+const FILTER_OP = /^(eq|neq|gt|gte|lt|lte|like|ilike|is|in|cs|cd|ov|fts|not|match)$/i;
+/** Columns referenced in PostgREST `or` / `and` filter strings. */
+function filterColumns(filter) {
+    const cols = [];
+    const walk = (s) => {
+        const trimmed = s.trim();
+        if (!trimmed)
+            return;
+        const grouped = trimmed.match(/^(and|or)\((.*)\)$/i);
+        if (grouped) {
+            for (const part of splitTopLevel(grouped[2], ","))
+                walk(part);
+            return;
+        }
+        const notWrap = trimmed.match(/^not\((.*)\)$/i);
+        if (notWrap) {
+            walk(notWrap[1]);
+            return;
+        }
+        const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_.]*)\.(eq|neq|gt|gte|lt|lte|like|ilike|is|in|cs|cd|ov|fts|not|match)\b/i);
+        if (match && FILTER_OP.test(match[2])) {
+            cols.push(match[1]);
+            return;
+        }
+        const re = /([A-Za-z_][A-Za-z0-9_.]*)\.(eq|neq|gt|gte|lt|lte|like|ilike|is|in|cs|cd|ov|fts|not|match)\b/gi;
+        let m;
+        while ((m = re.exec(trimmed)))
+            cols.push(m[1]);
+    };
+    walk(filter);
+    return cols;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,54 @@
+export interface Relationship {
+    foreignKeyName: string;
+    columns: string[];
+    isOneToOne: boolean;
+    referencedRelation: string;
+    referencedColumns: string[];
+}
+export interface RpcFunction {
+    name: string;
+    argNames: Set<string>;
+    requiredArgs: Set<string>;
+    argsNever: boolean;
+}
+export interface Relation {
+    schema: string;
+    name: string;
+    kind: "table" | "view";
+    columns: Set<string>;
+    insertColumns: Set<string>;
+    insertRequired: Set<string>;
+    updateColumns: Set<string>;
+    relationships: Relationship[];
+    /** string-literal domains for a column (enums / unions), if known */
+    valueDomain: Map<string, string[]>;
+}
+export interface Catalog {
+    schemas: Set<string>;
+    relations: Map<string, Relation>;
+    byName: Map<string, Relation[]>;
+    functions: Map<string, Map<string, RpcFunction>>;
+    enums: Map<string, Map<string, string[]>>;
+}
+export interface SelectItem {
+    alias: string | null;
+    name: string;
+    hints: string[];
+    children: SelectItem[] | null;
+}
+export interface QueryError {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+}
+export interface MethodCall {
+    name: string;
+    args: import("typescript").Expression[];
+    node: import("typescript").CallExpression;
+}
+export interface QueryBinding {
+    relation: Relation;
+    embeds: Map<string, Relation>;
+}
+export declare function relKey(schema: string, name: string): string;

package/dist/lib/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relKey = relKey;
+function relKey(schema, name) {
+    return `${schema}.${name}`;
+}

package/dist/run.d.ts

@@ -0,0 +1 @@
+export declare function run(): Promise<void>;

package/dist/run.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const cli_1 = require("./cli");
+const catalog_1 = require("./lib/catalog");
+const checker_1 = require("./lib/checker");
+const program_1 = require("./lib/program");
+const clients_1 = require("./utils/clients");
+const files_1 = require("./utils/files");
+function formatIssue(issue, kind) {
+    return `${kind} ${issue.file}:${issue.line}:${issue.column}  ${issue.message}`;
+}
+async function run() {
+    const { cwd, target, types } = await (0, cli_1.resolveCliPaths)();
+    const catalog = (0, catalog_1.loadCatalog)(types);
+    const files = (0, files_1.collectSourceFiles)(target, types);
+    const srcDir = node_fs_1.default.existsSync(node_path_1.default.join(target, "src")) ? node_path_1.default.join(target, "src") : target;
+    const program = (0, program_1.createBackendProgram)(target, files, types);
+    const tsChecker = program.getTypeChecker();
+    const clientNames = (0, clients_1.collectClientNames)(program, tsChecker);
+    const imported = (0, files_1.loadImportedConsts)(files, srcDir);
+    const errors = [];
+    const warnings = [];
+    const instantiated = new Set();
+    const pendingAny = [];
+    const makeChecker = (sf) => new checker_1.Checker({
+        catalog,
+        sf,
+        consts: (0, files_1.fileConsts)(sf, imported),
+        tsChecker,
+        clientNames,
+        instantiated,
+        pendingAny,
+        errors,
+        warnings,
+    });
+    for (const file of files) {
+        const sf = program.getSourceFile(file);
+        if (!sf)
+            continue;
+        makeChecker(sf).checkFile();
+    }
+    for (let i = 0; i < 20; i++) {
+        const before = pendingAny.length;
+        for (const file of files) {
+            const sf = program.getSourceFile(file);
+            if (!sf)
+                continue;
+            makeChecker(sf).followAnyPayloads();
+        }
+        if (pendingAny.length === before)
+            break;
+    }
+    (0, checker_1.flushUnhitAnyPayloads)(pendingAny, errors);
+    for (const warning of warnings)
+        console.warn(formatIssue(warning, "warning"));
+    for (const error of errors)
+        console.error(formatIssue(error, "error"));
+    const summary = `checked ${files.length} files in ${node_path_1.default.relative(cwd, target) || "."} against ${catalog.relations.size} relations`;
+    if (errors.length === 0) {
+        console.log(`${summary} — ok`);
+        return;
+    }
+    console.error(`\n${summary} — ${errors.length} error(s)`);
+    process.exitCode = 1;
+}

package/dist/utils/ast.d.ts

@@ -0,0 +1,50 @@
+import ts from "typescript";
+import type { MethodCall } from "../lib/types";
+export declare function loc(sf: ts.SourceFile, node: ts.Node): {
+    line: number;
+    column: number;
+};
+export declare function propName(name: ts.PropertyName): string | null;
+export declare function unwrapExpr(expr: ts.Expression): ts.Expression;
+export declare function evalString(expr: ts.Expression, consts: Map<string, string>, opts?: {
+    checker?: ts.TypeChecker;
+    subst?: Map<string, string>;
+}): string | null;
+/** All string-literal possibilities (unions / `a ? "id" : "slug"`). */
+export declare function evalStrings(expr: ts.Expression, consts: Map<string, string>, opts?: {
+    checker?: ts.TypeChecker;
+    subst?: Map<string, string>;
+}): string[] | null;
+export declare function stringish(expr: ts.Expression, consts: Map<string, string>, opts?: {
+    checker?: ts.TypeChecker;
+    subst?: Map<string, string>;
+}): {
+    text: string;
+    complete: boolean;
+} | null;
+export declare function bindingHasIdent(name: ts.BindingName, ident: string): boolean;
+export declare function enclosingParam(ident: ts.Identifier): {
+    fn: ts.FunctionLikeDeclaration;
+    index: number;
+} | null;
+export declare function isParameterIdentifier(ident: ts.Identifier): boolean;
+export declare function callReceiver(call: ts.CallExpression): ts.Expression | undefined;
+export declare function isArrayFrom(fromCall: MethodCall): boolean;
+export declare function chainProps(expr: ts.Expression): string[];
+export declare function collectChain(tail: ts.CallExpression): MethodCall[];
+export declare function chainRoot(tail: ts.CallExpression): ts.Expression | undefined;
+export declare function isChainTail(node: ts.CallExpression): boolean;
+export declare function assignedName(tail: ts.CallExpression): string | null;
+export declare function objectLiteral(expr: ts.Expression | undefined): ts.ObjectLiteralExpression | null;
+export declare function objectKeys(expr: ts.Expression | undefined): {
+    keys: string[];
+    hasSpread: boolean;
+} | null;
+export declare function optionString(args: ts.Expression[], options: string[], consts: Map<string, string>, opts?: {
+    checker?: ts.TypeChecker;
+    subst?: Map<string, string>;
+}): string | null;
+export declare function literalValue(expr: ts.Expression, consts: Map<string, string>, opts?: {
+    checker?: ts.TypeChecker;
+    subst?: Map<string, string>;
+}): string | number | boolean | null | undefined;