rado 0.1.18 → 0.1.20

package/dist/lib/Column.d.ts

@@ -1,4 +1,4 @@
-import { Expr, ExprData } from './Expr';
+import { EV, Expr, ExprData } from './Expr';
 export declare enum ColumnType {
     String = "String",
     Integer = "Integer",
@@ -10,7 +10,7 @@ interface PartialColumnData {
     type: ColumnType;
     name?: string;
     nullable?: boolean;
-    defaultValue?: any;
+    defaultValue?: ExprData;
     autoIncrement?: boolean;
     primaryKey?: boolean;
     unique?: boolean;
@@ -29,7 +29,7 @@ export declare class Column<T> {
     primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
     references(column: Expr<T>): Column<T>;
     unique(): Column<T>;
-    defaultValue(value: T): Column<Column.IsOptional<T>>;
+    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
 }
 export type PrimaryKey<T, K> = string extends K ? T : T & {
     [Column.isPrimary]: K;

package/dist/lib/Column.js

@@ -31,7 +31,7 @@ var Column = class {
     return new Column({ ...this.data, unique: true });
   }
   defaultValue(value) {
-    return new Column({ ...this.data, defaultValue: value });
+    return new Column({ ...this.data, defaultValue: ExprData.create(value) });
   }
 };
 ((Column2) => {

package/dist/lib/Formatter.js

@@ -167,8 +167,13 @@ var Formatter = class {
   }
   formatColumn(column) {
     return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "UNIQUE").addIf(column.autoIncrement, "AUTOINCREMENT").addIf(column.primaryKey, "PRIMARY KEY").addIf(!column.nullable, "NOT NULL").addIf(
-      column.defaultValue !== void 0,
-      raw("DEFAULT").add(this.formatInlineValue(column.defaultValue))
+      column.defaultValue,
+      () => raw("DEFAULT").addParenthesis(
+        this.formatExpr(column.defaultValue, {
+          formatAsJson: false,
+          forceInline: true
+        })
+      )
     ).addIf(column.references, () => {
       return this.formatContraintReference(column.references);
     });
@@ -205,8 +210,10 @@ var Formatter = class {
   }
   formatColumnValue(column, columnValue) {
     const isNull = columnValue === void 0 || columnValue === null;
-    const isOptional = column.nullable || column.autoIncrement || column.primaryKey || column.defaultValue !== void 0;
+    const isOptional = column.nullable || column.autoIncrement || column.primaryKey;
     if (isNull) {
+      if (column.defaultValue !== void 0)
+        return this.formatExpr(column.defaultValue, {});
       if (!isOptional)
         throw new TypeError(`Expected value for column ${column.name}`);
       return raw("NULL");

package/dist/lib/Schema.js

@@ -10,6 +10,9 @@ var Schema;
     return Query.Batch({ queries });
   }
   Schema2.create = create;
+  function removeLeadingWhitespace(str) {
+    return str.replace(/\n\s+/g, "\n");
+  }
   function upgrade(formatter, local, schema) {
     const columnNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.columns),
@@ -25,7 +28,7 @@ var Schema;
         res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
       } else {
         const [instruction] = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
-        if (localInstruction !== instruction) {
+        if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
         }
       }
@@ -45,7 +48,7 @@ var Schema;
         const [instruction] = formatter.formatCreateIndex(
           Query.CreateIndex({ table: schema, index: schemaIndex })
         ).compile(formatter);
-        if (localInstruction !== instruction) {
+        if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.DropIndex({ table: schema, name: indexName }));
           res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
         }

package/dist/lib/Statement.d.ts

@@ -16,6 +16,10 @@ declare class Token {
     static Identifier(data: string): Token;
     static Value(data: any): Token;
 }
+export interface CompileOptions {
+    formatInline?: boolean;
+    spaces?: number;
+}
 export declare class Statement {
     tokens: Array<Token>;
     constructor(tokens: Array<Token>);
@@ -30,7 +34,7 @@ export declare class Statement {
     addIf(condition: any, addition: string | Statement | (() => string | Statement)): Statement;
     indent(): Statement;
     dedent(): Statement;
-    newline(): Statement;
+    newline(ignore?: boolean): Statement;
     identifier(name: string): Statement;
     addIdentifier(name: string): Statement;
     value(value: any): Statement;

package/dist/lib/Statement.js

@@ -76,7 +76,9 @@ var Statement = class {
   dedent() {
     return this.concat(Token.Dedent());
   }
-  newline() {
+  newline(ignore = false) {
+    if (ignore)
+      return this;
     return this.raw(NEWLINE);
   }
   identifier(name) {

package/dist/sqlite/SqliteFunctions.d.ts

@@ -148,3 +148,9 @@ export type SqliteFunctions = {
     julianday(timeValue: EV<any>, ...rest: Array<EV<string>>): Expr<string>;
     strftime(format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>): Expr<string>;
 };
+export declare const match: (table: Table<any>, searchTerm: EV<string>) => Expr<boolean>, cast: {
+    (x: EV<any>, type: 'text'): Expr<string>;
+    (x: EV<any>, type: 'real'): Expr<number>;
+    (x: EV<any>, type: 'integer'): Expr<number>;
+    (x: EV<any>, type: 'numeric'): Expr<number>;
+}, abs: (x: EV<number>) => Expr<number>, changes: () => Expr<number>, char: (...arg: Array<EV<number>>) => Expr<string>, coalesce: (x: EV<any>, y: EV<any>, ...rest: EV<any>) => Expr<any>, ifnull: <T>(x: EV<T>, y: EV<T>) => Expr<T>, iif: <T>(x: EV<boolean>, y: EV<T>, z: EV<T>) => Expr<T>, instr: (x: EV<string>, y: EV<string>) => Expr<number>, last_insert_rowid: () => Expr<number>, length: (x: EV<string>) => Expr<number>, likelihood: (x: EV<boolean>, y: number) => Expr<boolean>, likely: (x: EV<boolean>) => Expr<boolean>, lower: (x: EV<string>) => Expr<string>, ltrim: (x: EV<string>, y?: EV<string>) => Expr<string>, max: <T>(x: EV<T>, y: EV<T>, ...rest: EV<T>[]) => Expr<T>, min: <T>(x: EV<T>, y: EV<T>, ...rest: EV<T>[]) => Expr<T>, nullif: <T>(x: EV<T>, y: EV<T>) => Expr<T | null>, prnumberf: (format: string, ...rest: Array<Expr<any>>) => Expr<string>, quote: (x: EV<string>) => Expr<string>, random: () => Expr<number>, replace: (x: EV<string>, y: EV<string>, z: EV<string>) => Expr<string>, round: (x: EV<number>, y?: EV<number>) => Expr<number>, rtrim: (x: EV<string>, y?: EV<string>) => Expr<string>, sign: (x: EV<number>) => Expr<number>, soundex: (x: EV<string>) => Expr<string>, sqlite_version: () => Expr<string>, substr: (x: EV<string>, y: EV<number>, z?: EV<number>) => Expr<string>, total_changes: () => Expr<number>, trim: (x: EV<string>, Y: EV<string>) => Expr<string>, unicode: (x: EV<string>) => Expr<number>, unlikely: (x: EV<boolean>) => Expr<boolean>, upper: (x: EV<string>) => Expr<string>, avg: (x: Expr<number>) => Expr<number>, count: (x?: Expr<any>) => Expr<number>, group_concat: (x: EV<string>, y: EV<string>) => Expr<string>, sum: (x: EV<number>) => Expr<number>, acos: (x: EV<number>) => Expr<number>, acosh: (x: EV<number>) => Expr<number>, asin: (x: EV<number>) => Expr<number>, asinh: (x: EV<number>) => Expr<number>, atan: (x: EV<number>) => Expr<number>, atan2: (x: EV<number>, y: EV<number>) => Expr<number>, atanh: (x: EV<number>) => Expr<number>, ceil: (x: EV<number>) => Expr<number>, cos: (x: EV<number>) => Expr<number>, cosh: (x: EV<number>) => Expr<number>, degrees: (x: EV<number>) => Expr<number>, exp: (x: EV<number>) => Expr<number>, floor: (x: EV<number>) => Expr<number>, ln: (x: EV<number>) => Expr<number>, log: (x: EV<number>, y?: EV<number>) => Expr<number>, log2: (x: EV<number>) => Expr<number>, mod: (x: EV<number>, y: EV<number>) => Expr<number>, pi: (x: EV<number>) => Expr<number>, pow: (x: EV<number>, y: EV<number>) => Expr<number>, radians: (x: EV<number>) => Expr<number>, sin: (x: EV<number>) => Expr<number>, sinh: (x: EV<number>) => Expr<number>, sqrt: (x: EV<number>) => Expr<number>, tan: (x: EV<number>) => Expr<number>, tanh: (x: EV<number>) => Expr<number>, trunc: (x: EV<number>) => Expr<number>, date: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, time: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, datetime: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, julianday: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, strftime: (format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>;

package/dist/sqlite/SqliteFunctions.js

@@ -1,6 +1,144 @@
 // src/sqlite/SqliteFunctions.ts
 import { Functions } from "../lib/Functions.js";
 var SqliteFunctions = Functions;
+var {
+  match,
+  cast,
+  abs,
+  changes,
+  char,
+  coalesce,
+  ifnull,
+  iif,
+  instr,
+  last_insert_rowid,
+  length,
+  likelihood,
+  likely,
+  lower,
+  ltrim,
+  max,
+  min,
+  nullif,
+  prnumberf,
+  quote,
+  random,
+  replace,
+  round,
+  rtrim,
+  sign,
+  soundex,
+  sqlite_version,
+  substr,
+  total_changes,
+  trim,
+  unicode,
+  unlikely,
+  upper,
+  avg,
+  count,
+  group_concat,
+  sum,
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  ceil,
+  cos,
+  cosh,
+  degrees,
+  exp,
+  floor,
+  ln,
+  log,
+  log2,
+  mod,
+  pi,
+  pow,
+  radians,
+  sin,
+  sinh,
+  sqrt,
+  tan,
+  tanh,
+  trunc,
+  date,
+  time,
+  datetime,
+  julianday,
+  strftime
+} = SqliteFunctions;
 export {
-  SqliteFunctions
+  SqliteFunctions,
+  abs,
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  avg,
+  cast,
+  ceil,
+  changes,
+  char,
+  coalesce,
+  cos,
+  cosh,
+  count,
+  date,
+  datetime,
+  degrees,
+  exp,
+  floor,
+  group_concat,
+  ifnull,
+  iif,
+  instr,
+  julianday,
+  last_insert_rowid,
+  length,
+  likelihood,
+  likely,
+  ln,
+  log,
+  log2,
+  lower,
+  ltrim,
+  match,
+  max,
+  min,
+  mod,
+  nullif,
+  pi,
+  pow,
+  prnumberf,
+  quote,
+  radians,
+  random,
+  replace,
+  round,
+  rtrim,
+  sign,
+  sin,
+  sinh,
+  soundex,
+  sqlite_version,
+  sqrt,
+  strftime,
+  substr,
+  sum,
+  tan,
+  tanh,
+  time,
+  total_changes,
+  trim,
+  trunc,
+  unicode,
+  unlikely,
+  upper
 };

package/dist/sqlite/SqliteSchema.js

@@ -28,7 +28,7 @@ var SqliteSchema;
       column.name,
       identifier(column.name).add(column.type).addIf(column.pk === 1, "PRIMARY KEY").addIf(column.notnull === 1, "NOT NULL").addIf(
         column.dflt_value !== null,
-        raw("DEFAULT").add(column.dflt_value)
+        raw("DEFAULT").addParenthesis(column.dflt_value)
       ).compile(formatter)[0]
     ];
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "license": "MIT",
   "type": "module",
   "exports": {