@nuxodin/item 0.6.10 → 0.6.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxodin/item",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "Reactive state library",
   "type": "module",
   "license": "MIT",

package/tools/db/sql.d.ts

@@ -10,6 +10,8 @@ export interface SqlTag {
     id(name: string | { toString(): string } | Promise<string | { toString(): string }>): Sql;
     raw(text: string): Sql;
     join(frags: Sql[], separator?: string): Sql;
+    in(col: string | Sql, values: Iterable<unknown>): Sql;
+    notIn(col: string | Sql, values: Iterable<unknown>): Sql;
 }
 
 export const sql: SqlTag;

package/tools/db/sql.js

@@ -38,6 +38,26 @@ sql.join = (frags, separator = ', ') => {
     return new Sql(parts);
 };
 
+/** A column: a name is quoted per dialect, `a.b` in its parts; anything else is a fragment already. */
+const column = (c) => typeof c === 'string' ? sql.join(c.split('.').map(n => sql.id(n)), '.') : c;
+
+/**
+ * `x IN (…)`, and a plain `false` where there is nothing to be in — `IN ()` is a syntax error, and
+ * an empty subquery cannot be typed for every column (`IN (SELECT NULL WHERE FALSE)` is a type
+ * error in postgres). The column belongs inside for exactly that reason: only there can the empty
+ * case be a boolean instead of a comparison.
+ */
+sql.in = (col, values) => {
+    const list = [...values];
+    return list.length ? sql`${column(col)} IN (${sql.join(list.map(v => sql`${v}`))})` : sql.raw('false');
+};
+
+/** The other way round — and nothing to be in means everything qualifies. */
+sql.notIn = (col, values) => {
+    const list = [...values];
+    return list.length ? sql`${column(col)} NOT IN (${sql.join(list.map(v => sql`${v}`))})` : sql.raw('true');
+};
+
 // Objects with their own toString bind as strings; plain objects/arrays are
 // mistakes (drivers would mangle them, e.g. mysql2's `key`='value' expansion).
 function toParam(v) {

package/tools/schema/db/sqlite/to-db.js

@@ -30,10 +30,12 @@ function emittable(prop, isSoloPk) {
     return out
 }
 
-function createBody(fields, primaries) {
+function createBody(table, fields, primaries) {
     const solo = soloIntPrimary(fields, primaries)
     const cols = fields.map(([n, f]) => {
         const isPk = n === solo
+        if (f['x-autoincrement'] && !isPk)
+            console.warn(`Skip AUTOINCREMENT ${table}.${n}: SQLite auto-increments only a sole INTEGER PRIMARY KEY — nothing fills this column`)
         // Only `INTEGER PRIMARY KEY` is the rowid alias, and AUTOINCREMENT is legal nowhere else —
         // so a boolean key keeps the integer spelling, which SQLite would otherwise reject.
         let def = toFieldDef(n, isPk ? { ...f, type: 'integer' } : f)
@@ -99,7 +101,7 @@ export async function schemaToDb(schema, query, { force = false, patch = false }
         const primaries = fields.filter(([, f]) => f['x-index'] === 'primary').map(([n]) => n)
 
         if (!currTables.includes(table)) {
-            stmts.push(`CREATE TABLE ${quoteId(table)} (\n${createBody(fields, primaries)}\n);`)
+            stmts.push(`CREATE TABLE ${quoteId(table)} (\n${createBody(table, fields, primaries)}\n);`)
             stmts.push(...indexStatements(table, fields, primaries))
         } else {
             const currFields = new Map(tableFields(current.properties[table]))
@@ -116,7 +118,7 @@ export async function schemaToDb(schema, query, { force = false, patch = false }
                 const keep     = fields.map(([n]) => n).filter(n => currFields.has(n))
                 const colsList = keep.map(quoteId).join(', ')
 
-                stmts.push(`CREATE TABLE ${quoteId(tmp)} (\n${createBody(fields, primaries)}\n);`)
+                stmts.push(`CREATE TABLE ${quoteId(tmp)} (\n${createBody(table, fields, primaries)}\n);`)
                 if (keep.length) stmts.push(`INSERT INTO ${quoteId(tmp)} (${colsList}) SELECT ${colsList} FROM ${quoteId(table)};`)
                 stmts.push(`DROP TABLE ${quoteId(table)};`)
                 stmts.push(`ALTER TABLE ${quoteId(tmp)} RENAME TO ${quoteId(table)};`)