@suss/sql 0.7.0

package/dist/index.d.cts

@@ -0,0 +1,44 @@
+/**
+ * What a SQL statement touches: which tables, which fields, and what it
+ * picks rows by.
+ *
+ * A pack that meets a query written as SQL rather than through an ORM
+ * hands the text here and gets the same shape its own recognizer would
+ * have produced. The statement is parsed rather than pattern-matched,
+ * so a join contributes every table it reads and a `WHERE` contributes
+ * a selector.
+ *
+ * A statement this cannot parse gives back nothing, which is what a
+ * reader that cannot settle something says everywhere else. The README
+ * says which dialects it reads and what it leaves out.
+ */
+/** One table a statement touches, and what it does to it. */
+interface SqlAccess {
+    table: string;
+    kind: "read" | "write";
+    /** The fields the statement states, or `["*"]` for a whole row. */
+    fields: string[];
+    /** The fields it picks rows by. */
+    selector: string[];
+}
+interface SqlReadOptions {
+    /** Which dialect the statement is written in. */
+    dialect?: string;
+}
+/** Every table a statement touches, or nothing when it cannot be read. */
+declare function readSqlAccess(sql: string, options?: SqlReadOptions): SqlAccess[];
+/**
+ * The SQL a tagged template states, with each interpolation written as
+ * a parameter. What a query interpolates is a value nearly every time,
+ * and a parameter is how the statement would carry one anyway, so the
+ * text parses as what it means.
+ *
+ * A caller that knows what an interpolation is passes it in
+ * `substitutions`, which is how a table interpolated as an object
+ * reaches the statement as its own name. An interpolation nobody can
+ * settle stays a parameter, and a statement that needed one somewhere a
+ * parameter cannot go reads as nothing.
+ */
+declare function sqlFromParts(parts: readonly string[], substitutions?: ReadonlyArray<string | null>): string;
+
+export { type SqlAccess, type SqlReadOptions, readSqlAccess, sqlFromParts };

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * What a SQL statement touches: which tables, which fields, and what it
+ * picks rows by.
+ *
+ * A pack that meets a query written as SQL rather than through an ORM
+ * hands the text here and gets the same shape its own recognizer would
+ * have produced. The statement is parsed rather than pattern-matched,
+ * so a join contributes every table it reads and a `WHERE` contributes
+ * a selector.
+ *
+ * A statement this cannot parse gives back nothing, which is what a
+ * reader that cannot settle something says everywhere else. The README
+ * says which dialects it reads and what it leaves out.
+ */
+/** One table a statement touches, and what it does to it. */
+interface SqlAccess {
+    table: string;
+    kind: "read" | "write";
+    /** The fields the statement states, or `["*"]` for a whole row. */
+    fields: string[];
+    /** The fields it picks rows by. */
+    selector: string[];
+}
+interface SqlReadOptions {
+    /** Which dialect the statement is written in. */
+    dialect?: string;
+}
+/** Every table a statement touches, or nothing when it cannot be read. */
+declare function readSqlAccess(sql: string, options?: SqlReadOptions): SqlAccess[];
+/**
+ * The SQL a tagged template states, with each interpolation written as
+ * a parameter. What a query interpolates is a value nearly every time,
+ * and a parameter is how the statement would carry one anyway, so the
+ * text parses as what it means.
+ *
+ * A caller that knows what an interpolation is passes it in
+ * `substitutions`, which is how a table interpolated as an object
+ * reaches the statement as its own name. An interpolation nobody can
+ * settle stays a parameter, and a statement that needed one somewhere a
+ * parameter cannot go reads as nothing.
+ */
+declare function sqlFromParts(parts: readonly string[], substitutions?: ReadonlyArray<string | null>): string;
+
+export { type SqlAccess, type SqlReadOptions, readSqlAccess, sqlFromParts };