Shuffle variable declarations to make functions GC-safe.

* Previously all ID types needed to have the `isZero` function defined.
  This was named after the UUID.isZero function but does not describe
  the general case. Non-numeric is types will not be "zero," they will
  be "empty." Renamed to `isEmpty` and implemented basic versions of
  this for `int`, `string`, and `UUID`.

* Previously newly created records were not allowed to have ids set.
  Fiber required them to be set in the database and the caller to
  retrieve the newly generated ID from the newly created record. This is
  not really a decision that Fiber should make in a general case. There
  are valid reasons for both possibilities (creating the id in the
  application code vs. creating the id in the database layer). As a
  more general-purpose solution Fiber now leaves this to the caller.

  If the caller provides an id value, Fiber will include it in the
  INSERT statement. If the id is unset, Fiber will not include it at
  all, allowing it to be generated in the database.

fiber_orm.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version       = "0.1.2"
+version       = "0.3.1"
 author        = "Jonathan Bernard"
 description   = "Lightweight Postgres ORM for Nim."
 license       = "GPL-3.0"
@@ -10,4 +10,4 @@ srcDir        = "src"
 
 # Dependencies
 
-requires "nim >= 1.0.4"
+requires "nim >= 1.4.0"

src/fiber_orm.nim

@@ -25,12 +25,12 @@ proc createRecord*[T](db: DbConn, rec: T): T =
     " RETURNING *"), mc.values)
 
   result = rowToModel(T, newRow)
-  
+
 proc updateRecord*[T](db: DbConn, rec: T): bool =
   var mc = newMutateClauses()
   populateMutateClauses(rec, false, mc)
 
-  let setClause = zip(mc.columns, mc.placeholders).mapIt(it.a & " = " & it.b).join(",")
+  let setClause = zip(mc.columns, mc.placeholders).mapIt(it[0] & " = " & it[1]).join(",")
   let numRowsUpdated = db.execAffectedRows(sql(
     "UPDATE " & tableName(rec) &
     " SET " & setClause &
@@ -50,8 +50,8 @@ template getRecord*(db: DbConn, modelType: type, id: typed): untyped =
     " FROM " & tableName(modelType) &
     " WHERE id = ?"), @[$id])
 
-  if row.allIt(it.len == 0):
-    raise newException(NotFoundError, "no record for id " & $id)
+  if allIt(row, it.len == 0):
+    raise newException(NotFoundError, "no " & modelName(modelType) & " record for id " & $id)
 
   rowToModel(modelType, row)
 
@@ -76,7 +76,7 @@ template findRecordsBy*(db: DbConn, modelType: type, lookups: seq[tuple[field: s
     lookups.mapIt(it.value))
   .mapIt(rowToModel(modelType, it))
 
-macro generateProcsForModels*(modelTypes: openarray[type]): untyped =
+macro generateProcsForModels*(dbType: type, modelTypes: openarray[type]): untyped =
   result = newStmtList()
 
   for t in modelTypes:
@@ -89,22 +89,22 @@ macro generateProcsForModels*(modelTypes: openarray[type]): untyped =
     let deleteName = ident("delete" & modelName)
     let idType = typeOfColumn(t, "id")
     result.add quote do:
-      proc `getName`*(db: PMApiDb, id: `idType`): `t` = getRecord(db.conn, `t`, id)
-      proc `getAllName`*(db: PMApiDb): seq[`t`] = getAllRecords(db.conn, `t`)
-      proc `findWhereName`*(db: PMApiDb, whereClause: string, values: varargs[string, dbFormat]): seq[`t`] =
+      proc `getName`*(db: `dbType`, id: `idType`): `t` = getRecord(db.conn, `t`, id)
+      proc `getAllName`*(db: `dbType`): seq[`t`] = getAllRecords(db.conn, `t`)
+      proc `findWhereName`*(db: `dbType`, whereClause: string, values: varargs[string, dbFormat]): seq[`t`] =
         return findRecordsWhere(db.conn, `t`, whereClause, values)
-      proc `createName`*(db: PMApiDb, rec: `t`): `t` = createRecord(db.conn, rec)
-      proc `updateName`*(db: PMApiDb, rec: `t`): bool = updateRecord(db.conn, rec)
-      proc `deleteName`*(db: PMApiDb, rec: `t`): bool = deleteRecord(db.conn, rec)
-      proc `deleteName`*(db: PMApiDb, id: `idType`): bool = deleteRecord(db.conn, `t`, id)
+      proc `createName`*(db: `dbType`, rec: `t`): `t` = createRecord(db.conn, rec)
+      proc `updateName`*(db: `dbType`, rec: `t`): bool = updateRecord(db.conn, rec)
+      proc `deleteName`*(db: `dbType`, rec: `t`): bool = deleteRecord(db.conn, rec)
+      proc `deleteName`*(db: `dbType`, id: `idType`): bool = deleteRecord(db.conn, `t`, id)
 
-macro generateLookup*(modelType: type, fields: seq[string]): untyped =
+macro generateLookup*(dbType: type, modelType: type, fields: seq[string]): untyped =
   let fieldNames = fields[1].mapIt($it)
-  let procName = ident("find" & $modelType.getType[1] & "sBy" & fieldNames.mapIt(it.capitalize).join("And"))
+  let procName = ident("find" & pluralize($modelType.getType[1]) & "By" & fieldNames.mapIt(it.capitalize).join("And"))
 
   # Create proc skeleton
   result = quote do:
-    proc `procName`*(db: PMApiDb): seq[`modelType`] =
+    proc `procName`*(db: `dbType`): seq[`modelType`] =
       return findRecordsBy(db.conn, `modelType`)
 
   var callParams = quote do: @[]
@@ -120,7 +120,7 @@ macro generateLookup*(modelType: type, fields: seq[string]): untyped =
 
   result[6][0][0].add(callParams)
 
-macro generateProcsForFieldLookups*(modelsAndFields: openarray[tuple[t: type, fields: seq[string]]]): untyped =
+macro generateProcsForFieldLookups*(dbType: type, modelsAndFields: openarray[tuple[t: type, fields: seq[string]]]): untyped =
   result = newStmtList()
 
   for i in modelsAndFields:
@@ -131,7 +131,7 @@ macro generateProcsForFieldLookups*(modelsAndFields: openarray[tuple[t: type, fi
 
     # Create proc skeleton
     let procDefAST = quote do:
-      proc `procName`*(db: PMApiDb): seq[`modelType`] =
+      proc `procName`*(db: `dbType`): seq[`modelType`] =
         return findRecordsBy(db.conn, `modelType`)
 
     var callParams = quote do: @[]
@@ -139,7 +139,7 @@ macro generateProcsForFieldLookups*(modelsAndFields: openarray[tuple[t: type, fi
     # Add dynamic parameters for the proc definition and inner proc call
     for n in fieldNames:
       let paramTuple = newNimNode(nnkPar)
-      paramTuple.add(newColonExpr(ident("field"), newLit(n)))
+      paramTuple.add(newColonExpr(ident("field"), newLit(identNameToDb(n))))
       paramTuple.add(newColonExpr(ident("value"), ident(n)))
 
       procDefAST[3].add(newIdentDefs(ident(n), ident("string")))

src/fiber_orm/util.nim

@@ -1,13 +1,7 @@
 import json, macros, options, sequtils, strutils, times, timeutils, unicode,
   uuids
 
-const UNDERSCORE_RUNE = "_".toRunes[0]
-const PG_TIMESTAMP_FORMATS = [
-  "yyyy-MM-dd HH:mm:sszz",
-  "yyyy-MM-dd HH:mm:ss'.'fzz",
-  "yyyy-MM-dd HH:mm:ss'.'ffzz",
-  "yyyy-MM-dd HH:mm:ss'.'fffzz"
-]
+import nre except toSeq
 
 type
   MutateClauses* = object
@@ -17,7 +11,7 @@ type
 
 # TODO: more complete implementation
 # see https://github.com/blakeembrey/pluralize
-proc pluralize(name: string): string =
+proc pluralize*(name: string): string =
   if name[^2..^1] == "ey": return name[0..^3] & "ies"
   if name[^1] == 'y': return name[0..^2] & "ies"
   return name & "s"
@@ -28,7 +22,9 @@ macro modelName*(model: object): string =
 macro modelName*(modelType: type): string =
   return newStrLitNode($modelType.getType[1])
 
+
 proc identNameToDb*(name: string): string =
+  const UNDERSCORE_RUNE = "_".toRunes[0]
   let nameInRunes = name.toRunes
   var prev: Rune
   var resultRunes = newSeq[Rune]()
@@ -68,10 +64,38 @@ type DbArrayParseState = enum
   expectStart, inQuote, inVal, expectEnd
 
 proc parsePGDatetime*(val: string): DateTime =
+
+  const PG_TIMESTAMP_FORMATS = [
+    "yyyy-MM-dd HH:mm:ss",
+    "yyyy-MM-dd HH:mm:sszz",
+    "yyyy-MM-dd HH:mm:ss'.'fff",
+    "yyyy-MM-dd HH:mm:ss'.'fffzz"
+  ]
+
+  let PG_PARTIAL_FORMAT_REGEX = re"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.)(\d{1,3})(\S+)?"
+
   var errStr = ""
+
+  # Try to parse directly using known format strings.
   for df in PG_TIMESTAMP_FORMATS:
     try: return val.parse(df)
-    except: errStr &= "\n" & getCurrentExceptionMsg()
+    except: errStr &= "\n\t" & getCurrentExceptionMsg()
+
+  # PostgreSQL will truncate any trailing 0's in the millisecond value leading
+  # to values like `2020-01-01 16:42.3+00`. This cannot currently be parsed by
+  # the standard times format as it expects exactly three digits for
+  # millisecond values. So we have to detect this and pad out the millisecond
+  # value to 3 digits.
+  let match = val.match(PG_PARTIAL_FORMAT_REGEX)
+  if match.isSome:
+    let c = match.get.captures
+    try:
+      let corrected = c[0] & alignLeft(c[1], 3, '0') & c[2]
+      return corrected.parse(PG_TIMESTAMP_FORMATS[1])
+    except:
+      errStr &= "\n\t" & PG_TIMESTAMP_FORMATS[1] &
+        " after padding out milliseconds to full 3-digits"
+
   raise newException(ValueError, "Cannot parse PG date. Tried:" & errStr)
 
 proc parseDbArray*(val: string): seq[string] =
@@ -144,7 +168,11 @@ proc createParseStmt*(t, value: NimNode): NimNode =
       result = quote do: parsePGDatetime(`value`)
 
     elif t.getTypeInst == Option.getType:
-      let innerType = t.getTypeImpl[2][0][0][1]
+      var innerType = t.getTypeImpl[2][0] # start at the first RecList
+      # If the value is a non-pointer type, there is another inner RecList
+      if innerType.kind == nnkRecList: innerType = innerType[0]
+      innerType = innerType[1] # now we can take the field type from the first symbol
+
       let parseStmt = createParseStmt(innerType, value)
       result = quote do:
         if `value`.len == 0:  none[`innerType`]()
@@ -173,9 +201,16 @@ proc createParseStmt*(t, value: NimNode): NimNode =
   elif t.typeKind == ntyInt:
     result = quote do: parseInt(`value`)
 
+  elif t.typeKind == ntyFloat:
+    result = quote do: parseFloat(`value`)
+
   elif t.typeKind == ntyBool:
     result = quote do: "true".startsWith(`value`.toLower)
 
+  elif t.typeKind == ntyEnum:
+    let innerType = t.getTypeInst
+    result = quote do: parseEnum[`innerType`](`value`)
+
   else:
     error "Unknown value type: " & $t.typeKind
 
@@ -241,11 +276,13 @@ proc typeOfColumn*(modelType: NimNode, colName: string): NimNode =
       else: error "Unknown column type: " & $fieldType.getTypeInst
 
     else: return fieldType
-      
+
   raise newException(Exception,
     "model of type '" & $modelType & "' has no column named '" & colName & "'")
 
-proc isZero(val: int): bool = return val == 0
+proc isEmpty(val: int): bool = return val == 0
+proc isEmpty(val: UUID): bool = return val.isZero
+proc isEmpty(val: string): bool = return val.isEmptyOrWhitespace
 
 macro populateMutateClauses*(t: typed, newRecord: bool, mc: var MutateClauses): untyped =
 
@@ -257,14 +294,14 @@ macro populateMutateClauses*(t: typed, newRecord: bool, mc: var MutateClauses):
       # grab the field, it's string name, and it's type
       let fieldName = $fieldIdent
 
-      # we do not update the ID, but we do check: if we're creating a new
-      # record, we should not have an existing ID
+      # We only add clauses for the ID field if we're creating a new record and
+      # the caller provided a value..
       if fieldName == "id":
         result.add quote do:
-          if `newRecord` and not `t`.id.isZero:
-            raise newException(
-              AssertionError,
-              "Trying to create a new record, but the record already has an ID (" & $(`t`.id) & ").")
+          if `newRecord` and not `t`.id.isEmpty:
+            `mc`.columns.add(identNameToDb(`fieldName`))
+            `mc`.placeholders.add("?")
+            `mc`.values.add(dbFormat(`t`.`fieldIdent`))
 
       # if we're looking at an optional field, add logic to check for presence
       elif fieldType.kind == nnkBracketExpr and
@@ -273,7 +310,7 @@ macro populateMutateClauses*(t: typed, newRecord: bool, mc: var MutateClauses):
 
         result.add quote do:
           `mc`.columns.add(identNameToDb(`fieldName`))
-          if `t`.`fieldIdent`.isSome:
+          if isSome(`t`.`fieldIdent`):
             `mc`.placeholders.add("?")
             `mc`.values.add(dbFormat(`t`.`fieldIdent`.get))
           else: