add property-upsert-test

clj-e2e/test/logseq/e2e/plugins_basic_test.clj

@@ -34,6 +34,11 @@
         ;; Convert to lowercase
         (clojure.string/lower-case))))
 
+(let [*idx (atom 0)]
+  (defn- new-property
+    []
+    (str "p" (swap! *idx inc))))
+
 (defn- ls-api-call!
   [tag & args]
   (let [tag (name tag)
@@ -106,12 +111,38 @@
         (is (= (get props ":plugin.property._test_plugin/p3") false))
         (is (= (get props ":plugin.property._test_plugin/p2") "p2-updated"))))))
 
+(deftest property-upsert-test
+  (testing "property with default settings"
+    (let [p (new-property)]
+      (ls-api-call! :editor.upsertProperty p)
+      (let [property (ls-api-call! :editor.getProperty p)]
+        (is (= "default" (get property "type")))
+        (is (= ":db.cardinality/one" (get property "cardinality"))))))
+  (testing "property with specified cardinality && type"
+    (let [p (new-property)]
+      (ls-api-call! :editor.upsertProperty p {:type "number"
+                                              :cardinality "one"})
+      (let [property (ls-api-call! :editor.getProperty p)]
+        (is (= "number" (get property "type")))
+        (is (= ":db.cardinality/one" (get property "cardinality")))))
+    (let [p (new-property)]
+      (ls-api-call! :editor.upsertProperty p {:type "number"
+                                              :cardinality "many"})
+      (let [property (ls-api-call! :editor.getProperty p)]
+        (is (= "number" (get property "type")))
+        (is (= ":db.cardinality/many" (get property "cardinality"))))))
+  ;; TODO: How to test against eval-js errors on playwright?
+  #_(testing ":checkbox property doesn't allow :many cardinality"
+      (let [p (new-property)]
+        (ls-api-call! :editor.upsertProperty p {:type "checkbox"
+                                                :cardinality "many"}))))
+
 (deftest property-related-test
   (testing "properties management related apis"
     (dorun
      (map-indexed
       (fn [idx property-type]
-        (let [property-name (str "property-" idx)
+        (let [property-name (str "p" idx)
               _ (ls-api-call! :editor.upsertProperty property-name {:type property-type})
               property (ls-api-call! :editor.getProperty property-name)]
           (is (= (get property "ident") (str ":plugin.property._test_plugin/" property-name)))

deps/outliner/src/logseq/outliner/property.cljs

@@ -574,6 +574,10 @@
                                              :payload {:message "Property failed to create. Please try a different property name."
                                                        :type :error}})))))]
     (assert (qualified-keyword? db-ident))
+    (when (and (contains? #{:checkbox} (:logseq.property/type  schema))
+               (= :db.cardinality/many (:db/cardinality schema)))
+      (throw (ex-info ":checkbox property doesn't allow multiple values" {:property-id property-id
+                                                                          :schema schema})))
     (if-let [property (and (qualified-keyword? property-id) (d/entity db db-ident))]
       (update-property conn db-ident property schema opts)
       (let [k-name (or (and property-name (name property-name))

src/main/logseq/api/db_based.cljs

@@ -96,6 +96,23 @@
                      (sdk-utils/normalize-keyword-for-json)
                      (bean/->js)))))
 
+(defn ->cardinality
+  [input]
+  (let [valid-input #{"one" "many" "db.cardinality/one" "db.cardinality/many"}]
+    (when-not (contains? valid-input input)
+      (throw (ex-info "Invalid cardinality, choices: \"one\" or \"many\"" {:input input})))
+    (let [result (keyword input)]
+      (case result
+        :one :db.cardinality/one
+        :many :db.cardinality/many
+        result))))
+
+(defn- schema-type-check!
+  [type]
+  (let [valid-types #{:default :number :date :datetime :checkbox :url :node :json :string}]
+    (when-not (contains? valid-types type)
+      (throw (ex-info (str "Invalid type, type should be one of: " valid-types) {:type type})))))
+
 (defn upsert-property
   "schema:
     {:type :default | :number | :date | :datetime | :checkbox | :url | :node | :json | :string
@@ -115,9 +132,11 @@
              schema (or (some-> schema (bean/->clj)
                                 (update-keys #(if (contains? #{:hide :public} %)
                                                 (keyword (str (name %) "?")) %))) {})
+             _ (when (:type schema)
+                 (schema-type-check! (:type schema)))
              schema (cond-> schema
                       (string? (:cardinality schema))
-                      (-> (assoc :db/cardinality (keyword (:cardinality schema)))
+                      (-> (assoc :db/cardinality (->cardinality (:cardinality schema)))
                           (dissoc :cardinality))
 
                       (string? (:type schema))